Startseite .Net C# Archive nach Kategorien "Arrays"

Kategorie: Arrays

dynamisches StringArray definieren 

using System.Collections.Specialized;

// StringCollection erzeugen
StringCollection sclStrings = new StringCollection();

// beinhaltet sclStrings schon einen String namens "Horst"?
if (!sclStrings.Contains("Horst"))
{
    // String "Horst" hinzufügen
    sclStrings.Add("Horst");
}

// Anz. Einträge in der Stringliste ermitteln
int iCount = sclStrings.Count;

// Index von String "Horst" in der Liste ermitteln
int iIndex = sclStrings.IndexOf("Horst");

// String "Horst" entfernen
sclStrings.Remove("Horst");

// gesamten Inhalt der Stringliste löschen
sclStrings.Clear();

Teile eines byte-Arrays in ein anderes kopieren 

byte[] byaSourceData = { 0, 6, 7, 8, 2 };
byte[] byaDestinationData = new byte[2];

// 2 bytes von byaSourceData in byaDestinationData kopieren
// Start ist das byte mit Index 1 im Quell-Array
// Ziel ist Byte mit Index 0 im Ziel-Array
Buffer.BlockCopy(byaSourceData, 1, byaDestinationData, 0, 2);

// byaDestinationData beinhaltet nun 6, 7
Console.WriteLine(byaDestinationData.ToString());

Klasse für eine dynamische Baumstruktur 

class CTreeNode
{
    private uint _uiID = 0;
    private string _sName = string.Empty;
    private double _dValue = 0.0;
    private List<CTreeNode> _Childs = null;

    public uint ID
    {
        get
        {
            return _uiID;
        }
    }

    public string Name
    {
        get
        {
            return _sName;
        }
    }

    public double Value
    {
        get
        {
            return _dValue;
        }
        set
        {
            _dValue = value;
        }
    }

    // Addiert eigenen Wert zu allen Kind-Werten
    public double Sum
    {
        get
        {
            double dSum = _dValue;

            foreach (CTreeNode c in _Childs)
            {
                dSum += c.Sum;
            }

            return dSum;
        }
    }

    // Liste der Kind-Knoten
    public List<CTreeNode> Childs
    {
        get
        {
            return _Childs;
        }
    }

    public CTreeNode(uint uiID, string sName, double dValue)
    {
        _uiID = uiID;
        _sName = sName;
        _dValue = dValue;
        _Childs = new List<CTreeNode>();
    }
}

// Anwendung
CTreeNode r = new CTreeNode(0, "Wurzel", 1.0);

CTreeNode k1 = new CTreeNode(1, "Kind 1_1", 1.0);
CTreeNode k2 = new CTreeNode(2, "Kind 1_2", 2.0);
r.Childs.Add(k1);
r.Childs.Add(k2);

CTreeNode k3 = new CTreeNode(3, "Kind 2_1_1", 3.0);
CTreeNode k4 = new CTreeNode(4, "Kind 2_1_2", 4.0);
k1.Childs.Add(k3);
k1.Childs.Add(k4);

CTreeNode k5 = new CTreeNode(5, "Kind 2_2_1", 5.0);
CTreeNode k6 = new CTreeNode(6, "Kind 2_2_2", 6.0);
k2.Childs.Add(k5);
k2.Childs.Add(k6);

// dSum == 22.0
double dSum = r.Sum;

Statisches Array definieren 

// statische Arrays können nur innerhalb von unsafe-Structen verwendet werden
// zum kompilieren:
// Projekt->Eigenschaften->Erstellen->Unsicheren Code zulassen
// anwählen
public struct MyStruct
{
    public unsafe fixed float uffaValues[20];
}

Arrays sortieren 

// Integer sortieren
int[] iArray = { 0, 3, 1, 5, 7, 2, 5 };
Array.Sort(iArray);

// Strings sortieren
string[] sArray = { "Meier", "Schulze", "Lehmann" };
Array.Sort(sArray);

oder

// aufsteigend sortieren
public class SortASC : System.Collections.IComparer
{
    public int Compare(Object object1, Object object2)
    {
        return ((IComparable)object1).CompareTo(object2);
    }
}

// absteigend sortieren
public class SortDESC : System.Collections.IComparer
{
    public int Compare(Object object1, Object object2)
    {
        return -((IComparable)object1).CompareTo(object2);
    }
}

// aufsteigend sortieren 
string[] sNamen = { "Meier", "Schulze", "Lehmann" };
Array.Sort(sNamen, new SortASC());

// absteigend sortieren
Array.Sort(sNamen, new SortDESC());

List-Objekt

  • dynamisches Listenobjekt zum verwalten beliebiger Objekte
using System.Collections.Generic;

// Objekt, dass in die Liste soll
class TParameter
{
     public double a = 0.0;
     public double b = 0.0;
     public string sName = "";

     public TParameter(double da, double db, string sText)
     {
          a = da;
          b = db;
          sName = sText;
     }
}

// Liste erzeugen
List<TParameter> Parameters = new List<TParameter>();

// Element hinzufügen
Parameters.Add(new TParameter(0.2, 0.4, "P1"));

// erstes Element der Liste holen
TParameter Par = Parameters[0];

// alle Parameter in der Liste durchgehen
foreach (TParameter Par in Parameters)
{
    Par.a = 0.1;
}

// alle Elemente aus der Liste löschen
Parameters.Clear();

// Liste in eine andere gleichen Typs kopieren
Parameters.AddRange(SourceParameterList);

// ersten Parameter suchen, dessen Wert von a > 10.0 ist
TParameter Par = Parameters.Find(delegate(TParameter Par) { return Par.a > 10.0; });

// neue Liste erzeugen in der nur bestimmte Elemente einer alten Liste stehen
List<TParameter> NewParameters = Parameters.FindAll(delegate(TParameter Par) { return Par.a > 10.0; });

// einfache Methode zum Sortieren einer Liste
Parameters.Sort(delegate(TParameter Par1, TParameter Par2) { return Par1.sName.CompareTo(Par2.sName); });
  • eine weitere Methode zum Sortieren von List
using System.Collections.Generic;

// Objekt, dass in die Liste soll
// muß von IComparable abgeleitet sein, damit es über
// CompareTo() bei Aufruf von Sort verglichen werden kann
class TParameter : IComparable
{
     public double a = 0.0;
     public double b = 0.0;

     public TParameter(double da, double db)
     {
          a = da;
          b = db;
     }

     public int CompareTo(Object o) 
     {
        TParameter P = o as TParameter;

        int iRetVal = 0; // Grundinitialisierung für this.a == ((TParameter)o).a

        if (P != null)
        {
            if (this.a < P.a) iRetVal = -1; // Objekt ist kleiner als das Übergebene 
            else if (this.a > P.a) iRetVal = 1; // Objekt ist größer als das Übergebene
        }
        
        return iRetVal;
     }
}

// Verwendung
List list = new List();
list.Add(new TParameter(0.8, 0.2));
list.Add(new TParameter(0.5, 0.4));
list.Add(new TParameter(0.1, 0.1));
list.Sort(); // ruft CompareTo() auf
foreach (TParameter Par in list) Console.WriteLine(Par.a.ToString()+", "+Par.b.ToString());
  • Ausgabe von Elementen einer Stringliste
using System.Collections.Generic;

List<string> namen = new List<string>() { "Horst", "Ulf", "Jochen" };
string ausgabe = string.Join(", ", namen.ToArray());