How To: implement an Interface (part 2)

Mi è stato chiesto in un commento la differenza fra la dichiarazione esplicita e la dichiarazione implicita di un interfaccia.

A tal proposito mi sembra corretto proporre questo semplice esempio.

Due interfaccie che espongono gli stessi metodi, se le avessi implementate in modo
implicito avrei avuto il problema di comprendere l'appartenenza del metodo.

In questo modo "non solo il codice è più leggibile" ma mi consente "come" o "per chi"
sto lavorando !

public interface IRemoteClient
{
  void DoSend(byte[] bs);
  byte[] DoRecieve();
}

public interface ILocalClient
{
  void DoSend(byte[] bs);
  byte[] DoRecieve();
}


public class Fork : IRemoteClient, ILocalClient
{

  void IRemoteClient.DoSend(byte[] bs)
  {
      // send as Remote host
  }

  byte[] IRemoteClient.DoRecieve()
  {
      // recieve as Remote host
      return new byte[100];
  }

  void ILocalClient.DoSend(byte[] bs)
  {
            
  }

  byte[] ILocalClient.DoRecieve()
  {
      // recieve as Client 
      return new byte[100];
  }
}

How To: Abstrac class c#

In questo esempio, una classe astratta che viene estesa da due classi concrete.

L'esempio è sugli animali, e forse può sembrare sciocco, ma ogni tanto può far bene fare un sorriso anche mentre si lavora, che male non fa.

public abstract class animal
{
    public abstract void DoPlay();
    public abstract void DoSleep();
    public abstract void DoRun();
    public abstract void DoPee();
    public abstract void DoPoo();
}

public class dog : animal
{
    public override void DoPlay() { Console.WriteLine("arf arf"); }
    public override void DoSleep() { Console.WriteLine("ronf ronf"); }
    public override void DoRun() { Console.WriteLine("...."); }
    public override void DoPee() { Console.WriteLine("peeee.."); }
    public override void DoPoo() { Console.WriteLine("pof pof"); }        
}

public class cat : animal
{
    public override void DoPlay() { Console.WriteLine("meeehoww "); }
    public override void DoSleep() { Console.WriteLine("ronf ronf"); }
    public override void DoRun() { Console.WriteLine("...."); }
    public override void DoPee() { Console.WriteLine("peeee..sgrut sgrut"); }
    public override void DoPoo() { Console.WriteLine("pof pof"); }
}

public class myPet
{
    public myPet()
    { 
        animal mDog = new dog();
        animal mCat = new cat();
    }

How To: inherit tow classes

In questo esempio sono presentate due classi che fanno da base, ed una terza che le eredita.

Dato che in c# non è possibile ereditare due classi contemporaneamente, è necessario che la seconda erditi la prima in cascata.

La terza quindi altro non fa che implementare i metodi.

public class testBaseA
{
    public virtual void MethodBaseA() { }
}

public class testBaseB : testBaseA
{
    public virtual void MethodBaseB() { }
}


public class testAll : testBaseB
{
    public void TestAll()
    { 
        MethodBaseA();
        MethodBaseB();
    }

    public override void MethodBaseA()
    {
        int a = 0;
        a++;
        Console.WriteLine(a);
    }

    public override void MethodBaseB()
    {
        int b = 2;
        b++;
        Console.WriteLine(b);
    }
}

How To: implement multi Interface

In questo esempio decisamente interesante sono riportate 2 interfaccie e una classe che le implementa entrambe.

Nel caso d'uso prima di eseguire un metodo, ci si accerta che la classe implementi realmente l'interfaccia, tramite il tipo.

public interface interface1
{
    void methodInterface1(string p1);
}

public interface interface2
{
    void methodInterface2(string p1);
}


public class InterfacesTest : interface1, interface2
{

    public void methodInterface1(string p1)
    {
        Console.WriteLine(p1);
    }

    public void methodInterface2(string p1)
    {
        Console.WriteLine(p1);
    }
}

public class testUse
{
    private InterfacesTest test = new InterfacesTest();


    public void DoTest()
    {
        if (test.GetType().GetInterface("interface1") != null)
        {
            test.methodInterface1("A");
        }

        if (test.GetType().GetInterface("interface2") != null)
        {
            test.methodInterface2("B");
        }

    }        
}

How To: create an Enum

Ecco due esempi di come creare degli enumerativi.

Lo scopo di questo "prototipo" è di realizzare un elenco di elementi predefinito
per cui optare per una scelta.

public enum enumListType
{
    Combo =0,
    Bullet =1,
    List = 2
}

public enum enumListType
{
    Combo,
    Bullet,
    List
}

How To: Abstract Method C#

In questo esempio, sono rappresentate due classi una nominata Test e l'altra TestAbstract.

La prima è una semplice classe astratta con un metodo astratto (e quindi senza corpo) e un metodo virtuale con corpo ed ereditabile.

la seconda estende la prima.

public abstract class Test
{
   public abstract void testAbstract();

   public virtual void testVirtual()
   {
       Console.WriteLine("Test:step 1");
              
   }
}

public class TestAbstract : Test
{
   public override void testAbstract()
   {
       Console.WriteLine("TestAbstract:step 1");
   }

   public override void testVirtual()
   {
       base.testVirtual();
       Console.WriteLine("TestVirtual:step 2");
   }
}

public class useAbstract
{
   public void DoTest()
   {
       Test tA = new TestAbstract();

       tA.testAbstract(); //TestAbstract:step 1

       tA.testVirtual(); //Test:step 1 | TestAbstract:step 1
   }       
}

Mentre la terza classe è il caso d'uso, nel commento è riportato il flusso dell'output.

How To: implement an Interface

In questi esempi, due differenti modalità di implementare un interfaccia.

Test_A implementa ITest in modo classico.
Test_B implementa ITest Esplicitandola.

public interface ITest
{
   string TestProperty {get; set;}
   void TestMethod(string s);
}


public class Test_A : ITest
{

   string _s;

   //
   // Implementazione "classica"
   // 
   public string TestProperty
   {
       get{ return _s;}
       set { _s = value;}
   }

   public void TestMethod(string s)
   {
       Console.Write(s);
   }
}

public class Test_B : ITest
{

   string _s;

   //
   // Implementazione "esplicita"
   // 
   string ITest.TestProperty
   {
       get { return _s; }
       set { _s = value; }
   }

   void ITest.TestMethod(string s)
   {
       Console.Write(s);
   }
}

How To: Crate a Static Method

Questo esempio mostra come creare un metodo Statico in una classe non statica.

public class Test
{
   public static string staticMehotod(string value)
   {
       return "Parameter is :" + value;
   }
}

public class useTest
{
   public void UseStaticMethod()
   {
       string value = "Test";

       Console.WriteLine(Test.staticMehotod(value));
   }
}

How To: Write Binary File C#

Questo esempio, mostra come scrivere un file Binario utilizzando C#

FileStream fs = new FileStream("c:/testBin.txt",FileMode.OpenOrCreate);
BinaryWriter bw = new BinaryWriter(fs);

bw.Write(12345);
bw.Write(12.345);
bw.Write("simple text");

bw.Close();
fs.Close()

Decisamente semplice, ed è curioso il risultato...

How To: Write File C#

Come si fa a scrivere in un file in C# ?

string text = "testo da scrivere nel file.";
TextWriter tw = new StreamWriter ("c:/test.txt");
tw.WriteLine(text);
tw.Close();
tw = null;

E come si fa a scrivere un file in Append ?

string newText = "Testo in append";
TextWriter twAppend = new StreamWriter("c:/test.txt",true);
twAppend.WriteLine(newText);
twAppend.Close();
twAppend = null;

How To: Open File C#

Come si apre un file in lettura in C# ?

TextReader tr = new StreamReader("c:/test.txt");
string allFile = tr.ReadToEnd();
tr = null; 

Come si apre un file in lettura in C# ottenendo un arry di righe ?

TextReader tr = new StreamReader("c:/test.txt");
string[] allLine = tr.ReadToEnd().Replace("\r","").Split(new char[] { '\n' });
tr = null; 

Nel secondo caso rimpiazziamo "\r" in modo da dover Splittare solo per un carattere.

Contare le righe di un file aperto in lettura ?

TextReader tr = new StreamReader("c:/test.txt");
int lineCount = tr.ReadToEnd().Replace("\r","").Split(new char[] { '\n' }).Length;
tr = null;