beyarkay's questions

Como um exemplo simplificado do meu problema, tenho um array de ISomeType, e quero fazer um loop sobre todos os elementos naquele array que são realmente MyType, mas estou recebendo avisos IDE0220 "Add explicit cast in foreach loop" que não acho que se apliquem. Aqui está um exemplo de código:

public interface ISomeType {
    void DoThing();
}

public class MyType: ISomeType {
    void DoThing() { /* do something */ }
    void DoMyTypeThing() { /* do something specific to MyType */ }
}

public class YourType: ISomeType {
    void DoThing() { /* do something */ }
    void DoMyTypeThing() { /* do something specific to MyType */ }
}

ISomeType[] maybeMyTypes = [new MyType()];


// I get the error on this line because I cast the element into `MyType`
foreach (MyType foobar in maybeMyTypes.Where(i => i.GetType() == typeof(MyType))) {
    // use the MyType methods availbale on foobar
}

O compilador reclama que ele converte implicitamente os elementos de maybeFooBarsem MyType, e que isso pode falhar em tempo de execução, então devo ser explícito sobre a conversão:

// Code with violations.
var list = new List<object>();
foreach (string item in list) { }

// Fixed code.
var list = new List<object>();
foreach (string item in list.Cast<string>())

Meu código poderia realmente falhar em tempo de execução, já que estou verificando o tipo e apenas fazendo cast implicitamente se o tipo estiver correto? Ou o compilador C# não é inteligente o suficiente para ver que eu me protegi contra os tipos estarem incorretos?

Este código não irá simplesmente inverter os bits do inteiro de 16 bits como esperado:

#include <stdint.h>
typedef uint16_t U16;

U16 myNum = 0xffff;
~myNum // 0xffff0000, not 0x0000

Porque C promoverá o inteiro de 16 bits para um inteiro de 32 bits antes de fazer a inversão (veja 1 , 2 ).

Quais são minhas opções para inversão bitwise de 16 bits? Posso pensar em:

~myNum & 0xffff
// or 
((U16)~myNum)

Mas eles parecem propensos a erros/mal-entendidos. Será que estou sem sorte se eu quiser uma inversão de 16 bits bacana?

O seguinte aconteceu algumas vezes e estou procurando uma maneira automatizada de me pegar antes de repetir o erro. Soluções dizendo "apenas lembre-se" ou "simplesmente não faça isso" não serão marcadas como corretas.

Muitas vezes, estarei trabalhando em um branch do git, tenho algum código não confirmado e preciso fazer uma alteração rapidamente em outro branch. Eu costumo git stashesconder o código não confirmado, git checkoutpara trocar para o outro branch, faço e comprometo minhas alterações, então git checkoutpara o outro branch. E espero que eu me lembre de git stash pop. O problema é que nem sempre me lembro, especialmente se acabo tendo que fazer algumas alterações no outro branch que acabam levando algumas horas/dias.

Existe um hook git que eu possa escrever que, quando eu fizer checkout de um branch que tem um stash nele, ele me enviará uma pequena mensagem? Algo como:

$ git checkout foo
Switched to branch 'foo'
You have 1 stash on this branch, use `git stash pop` to unstash it.

Não precisa ser chique, mas acho que vai me poupar muita dor de cabeça. Respostas como "apenas lembre-se de correr git stash list" não serão aceitas.

Quero implementar o padrão typestate em C#. Eu tentei algo como:

interface Open {}
interface Closed {}

abstract class Foo<T> { }

class Bar<T> where T: Closed { }
class Bar<T> where T: Open { }

bem como outras permutações, mas todas acabam com a reclamação do compilador. Este exemplo específico fornece (via https://www.programiz.com/csharp-programming/online-compiler/ ):

/tmp/qmk1tTLHWG.cs(12,11): error CS0101: The namespace 'baz' already contains a definition for 'Bar'
/tmp/qmk1tTLHWG.cs(11,11): error CS0265: Partial declarations of 'Bar<T>' have inconsistent constraints for type parameter 'T'

Não sei o suficiente sobre o sistema de tipos do C# para saber o que realmente funcionará e não consigo encontrar muita documentação sobre como fazer isso. É possível implementar o padrão de estado de tipo? Encontrei o blog de Adam , mas ele na verdade não implementa o padrão de estado de tipo conforme mostrado em 1 , que é o que eu gostaria de fazer, se possível.

Idealmente eu gostaria de algo como

struct Closed { }; 
struct Open { };

class Foo<T> {
    // functions applicable to Foo's in both the Closed and Open states
}

class Foo<Closed> {
    // functions applicable to Foo's in just the Open state
}

class Foo<Open> {
    // functions applicable to Foo's in just the Open state
}