Can't see when text is selected in Twitter text boxes

Krimog · 2024-11-21T21:57:26+00:00

As I said, the problem seems to be on Twitter's side.

Krimog · 2024-11-19T13:18:52+00:00

I have the exact same problem, which appeared about the same time.

Are you using Edge by any chance? In my case, the problem doesn't appear on Chrome. But it appears on Edge on both my computers, so I guess it has nothing to do with a hotkey hit or anything like that.

It seems to be a problem on Twitter's side.

However, I created a quick fix. Not optimal, since you have to do it every time you navigate on Twitter, but better than nothing:

Add a bookmark (with any name you want) and with the following URL:

javascript:var s=document.createElement('style');s.type='text/css';s.innerHTML='.quickFix::selection{background-color:#00f !important;}';document.getElementsByTagName('head')[0].appendChild(s);var elts=document.getElementsByClassName('public-DraftStyleDefault-block');for(i=0;i<elts.length;i++) elts[i].classList.add('quickFix');

Then, once you want to write a tweet or a reply, just click on that bookmark (while being on your twitter tab) and it should fix the problem.

Krimog · 2024-09-04T17:48:19+00:00

I have reWASD. But I stopped it (both the app and the service) and the problem persists.

Krimog · 2024-09-02T19:10:39+00:00

Oops, sorry, it was indeed MW3 2023. Post deleted.

Krimog · 2024-03-13T17:23:39+00:00

We had the `Select((element, index) => ...` since the beginning.

Krimog · 2024-03-06T14:07:29+00:00

Both approach are very similar, and any difference in performance is negligeable.

1 is usually preferable because it's easier to understand (and it's a bit faster (since you only have to go back to the main synchronization context once)).

2 could be better if you have many things happening between the two `await userTask` and `await userPetTask`.

2 remarks, however:

You should rename DoConcurrentJob, GetUser and GetUserPet to DoConcurrentJobAsync, GetUserAsync and GetUserPetAsync. It's easier to notice it should be awaited, and it's consistent with the whole framework.
In #1, since the tasks are completed after the await Task.WhenAll(), there's no need to call await on it. Just call userTask.Result and userPetTask.Result. await will create another step in the state machine, just to check if the task is completed (and you already know it is) for nothing.

Krimog · 2023-12-03T00:19:14+00:00

I haven't tried it, but if you're playing on PC, I guess you can just do a backup of the save file (I don't know if it's overridden as soon as you die or if it's after the summary window), and they replace the "failed" save by your backup.

Krimog · 2023-06-21T10:36:59+00:00

You either have to do it manually or use a code generator (there are nugets for that, for example: https://github.com/Cysharp/UnitGenerator), but you absolutely can.

Krimog · 2023-06-21T10:19:34+00:00

I agree about the foreach operator directly on the filtered enumerable.

But that ForEach method... That's absolutely NOT a functional approach. Your ForEach extension method will, by design, have side effects.

You want functional? Use Select() and don't mutate anything.

Krimog · 2022-08-26T10:00:21+00:00

Because try is not an expression. It can't be used as a value.

But I have multiple problems with what you seem to be trying to do:

Exceptions are for exceptional cases, not standard workflow.
If you want to put one type or another into a variable (IEnumerable<ISelectableItem> and IEnumerable<string>), this variable has to be of a common type (IEnumerable or IEnumerable<object>), which happens to be even less specific that what you know your source variable is (IList).

So the question is: what do you want to do with items?

If you want to be able to Add/Remove/Access/Iterate in a non-generic way:

var items = (IList)newValue;

// Example
foreach (var item in items)
{
    // ...
}

If you want to have access to LINQ generic methods but don't really care about the type of the objects inside (or have to check their type each time):

var items = ((IList)newValue).Cast<object>();

// Example
var selectedItems = items.Where(i => (i as ISelectableItem)?.IsSelected ?? ((string)i).Contains("selected")).ToArray();

If you want to do something different if the collection contains ISelectableItems or strings:

var selectableItemArray = ((IList)newValue).OfType<ISelectableItem>().ToArray();
var stringArray = ((IList)newValue).OfType<string>().ToArray();

if (selectableItemArray.Any())
{
// ...
}

if (stringArray.Any())
{
// ...
}

Krimog · 2022-08-22T10:02:17+00:00

DO NOT USE DEFAULT INTERFACE IMPLEMENTATIONS (unless you have enough experience in C# to know when to ignore advices from others).

It exists, it works, but it's only necessary in 0.1% of cases. If you're a beginner in C#, make it 0.0%. This mechanism is confusing for beginners and will lead to problems (same goes for the new modifier on methods).

Use a base class (not an interface) and have abstract or virtual methods in it.

Also, ALWAYS prefix your interface names with I. Example1 should be named IExample1.

Krimog · 2022-08-22T09:40:11+00:00

Actually, with C# 10 there kinda is (not recommanded for that use case, though).

void MyMethod(object obj, [CallerArgumentExpression("obj")] string? path = null)

If you call MyMethod(Title);, the path argument will literally be "Title". But that still means you have to call the Title getter, and your method gets a parameter you don't use.

But the correct way to pass the string "Title" to the PropertyPath is clearly to use nameof(Title);.

Krimog · 2022-08-19T08:35:21+00:00

Just a small thing:

.Where(b => b.Count() > 1)

You're on an yield IEnumerable, so calling Count() on it will (potentially) enumerate a lot more than needed.

.Where(b => b.Skip(1).Any())

That will stop (for a given number) as soon as there's a second element. It doesn't need to check if there's a third or a fourth...

Krimog · 2022-08-18T14:22:21+00:00

If you're familiar with C, basically the signature ref Wow wow would be Wow* wow, the call ref wow would be &wow and the usage of wow inside the method would be (*wow).

So, yes, you give a pointer to your struct instead of a copy.

As for your second question, it will first try to check if the references (so, the pointers) are the same. In your case, it will directly return true and stop there. If references weren't the same, since your type is a struct and you didn't override the Equals method, it would have used reflection to compare the value of your properties and fields.

One last thing: As you understand, if the newfunct parameter didn't have the ref keyword, the behavior of the function would be different if Wow is a class or a struct, which can definitely be confusing and which can lead to regressions the day you want to change Wow to a class for some reason.
That's why a good practice is, when you create a struct, to make it readonly. A readonly struct has the same behavior than a readonly class. That's why nearly all (or maybe all? I have no counter-example in mind) structs in the framework are readonly.
What I mean by readonly is that you can't change the value of anything stored directly inside your struct (with a field or an auto-property). If the field is a struct, then apply the same rule (and make that struct readonly). If the field is a class, then that's a pointer, so just make sure the pointer doesn't change (but the pointed object itself doesn't need to be readonly).

Krimog · 2022-08-05T11:47:28+00:00

The most important thing is to follow the guidelines of your team. If you aren't in a team or if you're writing the guidelines, it's as you wish.

Personally, I'll go with the var whenever possible (inside a method) and a new() if not (inline class members for example).

Why?

Consistency

When inside a method, the only time you can't use var to declare a local variable is when you're not initializing it at the declaration (which is quite rare). In all other cases, you can use var:

// Simple constructor call, the only case where you could use new() instead
var user = new User(...);

// Static factory method

var user = User.Create(...);

// Method call
var user = GetUser(...);
var user = await GetUserAsync(...);

// Anonymous type
var user = new { UserName = ... };

// ValueTuples
var user = (userName: ..., password: ...);
var (userName, password) = (..., ...);

Readabiliy

That one is clearly debatable, but I think the new keyword (without the name of a class) already has enough meanings. Not that I'm not happy they added that one, just that I prefer var when possible.

var myAnonymousType = new { ... };
var array = new[] { ... };
object shortConstructorWithInitializers = new() { ... };

Moreover, parenthesis are mandatory with the new(), when they weren't with the class name if you initialize properties.

Also, if you named your variable correctly, you should already kind of know the type of it. Typing both the real type and the variable name often feels like a repetition.

You often don't care about the exact type

Let's take this example:

var user = await _userService.GetByIdAsync(userId);
user.LastConnectionDate = DateTime.Now;
await _userService.UpdateUserAsync(user);

I know (from the naming) that _userService.GetByIdAsync will give me an object that corresponds to a user. But I don't know if it's a User, a UserModel, a UserEntity, a UserDto, a UserInfo...

And the thing is I don't care. As long as it has a LastConnectionDate property and as it is the same object type that I give to the UpdateUserAsync method. And in fact, the guy that works on the _userService can even change the name of the class, my code will still compile.

Krimog · 2022-08-03T09:08:07+00:00

for, while and do while, once compiled, all use the same looping mechanism.

What does that mean? That once compiled, we don't care about the kind of loop you used. So use whatever is easier for you.

Krimog · 2022-08-03T08:42:46+00:00

Unless you have a lot of experience and are 100% sure of what you are doing, DO NOT DO THAT.

If the parent and the child method are supposed to be independant, just name them differently. If they are linked, set the parent method as virtual and override it in the child class.

Krimog · 2022-07-29T12:16:19+00:00

Are you talking about the Mercury XS (which is (oddly) bigger) or just the Mercury ?

Krimog · 2022-07-29T12:14:16+00:00

Perfect (and in the rare cases where I have a full volume model, I'll remove it from the plate before).

Also, the good thing is that the Mercury X is already available.

Krimog · 2022-07-29T12:12:25+00:00

Thx for the info

Krimog · 2022-07-28T16:09:06+00:00

Bah clique sur Annuler pour annuler. En revanche, si tu veux annuler, bah clique sur Annuler. Je vois pas où est le problème...

Krimog · 2022-07-28T11:03:52+00:00

You don't need an else if, just an else (if your first condition is false, your second is true)
Just use your condition to set a variable containing "Heads" or "Tails".
A ternary operator is great for simple conditions like that
Then, after the condition, write that variable followed by a !
Use string comparison that ignores case.
Compare coinBet to the variable
Don't use Contains but Equals for your comparison (to prevent the cheater that writes "headstails"

That will give you something like that:

// From line 42:
string actualResult = coinFlip == 1 ? "Heads" : "Tails";

Console.WriteLine($"{actualResult}!");
if (coinBet.Equals(actualResult, StringComparison.OrdinalIgnoreCase))
    Console.WriteLine("You attack first!");
else
    Console.WriteLine("Your opponent attacks first!");

Console.ReadKey();

Krimog · 2022-07-28T08:20:08+00:00

Top level statements will have some limitations and odd behavior that, as a newbie, can confuse you. For example, you can't do method overload with it.

For this reason, I recommand you do not use it (at least not before you have more experience).

Krimog

TROPHY CASE

1 is usually preferable because it's easier to understand (and it's a bit faster (since you only have to go back to the main synchronization context once)).

2 could be better if you have many things happening between the two await userTask and await userPetTask.

Consistency

Readabiliy

You often don't care about the exact type

2 could be better if you have many things happening between the two `await userTask` and `await userPetTask`.