C#

public interface MyRestApi
{
  string ApiName { get; set; }
  int Version { get; set; }
  string RequestBody { get; set; }
}

public interface MyRestApi
{
  string ApiName { get; set; }
  int Version { get; set; }
  string RequestBody { get; set; }
  uint Checksum() 
  {
    using CRC32 crc32 = new();
    byte[] data = Encoding.UTF8.GetBytes(RequestBody);
    byte[] hashBytes = crc32.ComputeHash(data);
    return BitConverter.ToUInt32(hashBytes, 0);
  }

}

public interface IExampleInterface
{
    // A method with a default implementation
    void DefaultMethod()
    {
        Console.WriteLine("This is the default implementation of DefaultMethod.");
    }

    // A static method
    static void StaticMethod()
    {
        Console.WriteLine("This is a static method in an interface.");
    }

}

public interface IFoo
{
    static void S() => Console.WriteLine("Default");
}

static void Test<T>() where T : IFoo
{
    // CS0704 Cannot do non-virtual member lookup in 'T' because it is a type parameter
    T.S();
}

public interface IFoo
{
    static virtual void S() => Console.WriteLine("Default");
}

public class Foo : IFoo
{
    // Why is this never called?
    static void S() => Console.WriteLine("Overridden");
}

static void Test<T>() where T : IFoo
{
    T.S();
}

Test<Foo>(); // Output: "Default"

public interface IFoo
{
    public static virtual void S() => Console.WriteLine("Default");
}

public class Foo : IFoo
{
    // CS0112 A static member cannot be marked as 'override'
    public static override void StaticMethod() => Console.WriteLine("Overridden");
}

Richard Deeming wrote:

adding access modifiers to interface members goes against the "ethos" of interfaces.

BillWoodruff wrote:

i am curious which versions of future C#/.NET your thorough review of future "features" are based on ...

https://www.reddit.com/r/csharp/comments/15o30l1/explicit_interface_reabstraction/[^]:

I had a question while reading the Microsoft docs on interfaces

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-8.0/default-interface-methods#reabstraction[^]

In the docs, they give the example

C#

interface IA
{
    void M() { WriteLine("IA.M"); }
}
interface IB : IA
{
    abstract void IA.M();
}
class C : IB { } // error: class 'C' does not implement 'IA.M'.

Which forces you to implement method M in class C. However, you can also define the interface IB this way, which also forces method M to be defined in class C.

C#

interface IA
{
    void M() { WriteLine("IA.M"); }
}
interface IB : IA
{
    new void M();
}
class C : IB { } // error: class 'C' does not implement 'IB.M'.

I did notice there is a small difference, where since in the second example, interface IB is shadowing IA, the error message changes, but in practice, is there any difference between these two?

private IDictionary<int, int> GetResultFromTextFile(IEnumerable<int> src)
{
    var filePath = @"C:\BoaSorte\Banco\testeResultado.txt";
    var delimiter = new[] { ' ' };
    var dict = File.ReadLines(filePath)
        .Where(line => !string.IsNullOrEmpty(line))
        .Aggregate(new Dictionary<int, int>(), (d, line) =>
        {
            var values = line
                .Split(delimiter, StringSplitOptions.RemoveEmptyEntries)
                .Select(x => int.Parse(x));
            var matchCount = values.Count(v => src.Contains(v)); //Count all matches...

            if (d.ContainsKey(matchCount))
                d[matchCount]++;
            else
                d[matchCount] = 1; //Store the count of repetitions, not the repeated count...

            return d;
        });

    return dict;
}

private void button1_Click(object sender, EventArgs e)
{
    int outVal;

    if (UltimoResultado.Any(Acertos => !int.TryParse(Acertos.Text, out outVal)))
    {
        MessageBox.Show("Valores Invalidos...");
        return;
    }
    
    var arr = UltimoResultado.Select(linha => int.Parse(linha.Text));
    var result = GetResultFromTextFile(arr).ToList();
    
    for (int i = 0; i < result.Count; i++)
    {
        dgHits.Rows[i].Cells["Acertos"].Value = result[i].Value.ToString(); //Display the value, not the key...
    }
}

if (d.ContainsKey(matchCount))
               d[matchCount]++;
           else
               d[matchCount] = 1;

<pre lang="C#">if (matchCount <= 15) { d[matchCount] = matchCount; } 

private IDictionary<int, int> GetResultFromTextFile(IEnumerable<int> src)
{
    var filePath = @"C:\BoaSorte\Banco\testeResultado.txt";
    var delimiter = new[] { ' ' };
    var dict = new Dictionary<int, int>();

    foreach (var line in File.ReadLines(filePath).Where(line => !string.IsNullOrEmpty(line)))
    {
        var values = line.Split(delimiter, StringSplitOptions.RemoveEmptyEntries)
                         .Select(x => int.Parse(x));
        var matchCount = values.Count(v => src.Contains(v));

        if (matchCount <= 15)
        {
            if (!dict.ContainsKey(matchCount))
            {
                dict[matchCount] = 0;
            }

            dict[matchCount]++;
        }
    }

    return dict;
}

private void button1_Click(object sender, EventArgs e)
{
    int outVal;

    if (UltimoResultado.Any(Acertos => !int.TryParse(Acertos.Text, out outVal)))
    {
        MessageBox.Show("Valores Invalidos...");
        return;
    }

    var arr = UltimoResultado.Select(linha => int.Parse(linha.Text));
    var result = GetResultFromTextFile(arr).ToList();

    for (int i = 0; i < result.Count; i++)
    {
        dgHits.Rows.Add(); // Add a new row
        dgHits.Rows[i].Cells["Acertos"].Value = result[i].Value.ToString();
    }
}

Andre Oosthuizen wrote:

C#

if (!dict.ContainsKey(matchCount))
{
    dict[matchCount] = 0;
}

dict[matchCount]++;

dict.TryGetValue(matchCount, out int existing);
dict[matchCount] = existing + 1;

string[] lines = File.ReadAllLines(@"C:\BoaSorte\Banco\testeResultado.txt");
            string[] line, contents, result;
            int count;
            result = textBox1.Text.Split(); 
            for (int i = 0; i < lines.Length; i++)
            {
                contents = lines[i].Split(' ');
                count = contents.Intersect(result).Count();
                line = new string[16];
                for (int j = 0; j < 15; j++)
                    line[j] = contents[j];
                line[15] = count.ToString();
                dgHits.Rows.Add(line);
            }

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        string url = "https://<your-domain>.sharepoint.com/sites/<site-name>/<library-name>/<file-path>";
        string accessToken = "<your-access-token>";

        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken}");
            HttpResponseMessage response = await client.GetAsync(url);
            if (response.IsSuccessStatusCode)
            {
                string content = await response.Content.ReadAsStringAsync();
                Console.WriteLine(content);
            }
            else
            {
                Console.WriteLine("Error: " + response.StatusCode);
            }
        }
    }
}

Richard Andrew x64 wrote:

a pretty close approximation of multiple inheritance.