Das habe ich mir schon gedacht. Habe es auch schon implementiert.
Kriege es aber trtozdem nicht gebacken.

		public override DataTemplate SelectTemplate(object item, DependencyObject container)
		{
			FrameworkElement element = container as FrameworkElement;

			if (item is Type1)
			{
				return element.FindResource("Type1") as DataTemplate;
			}
			if (item is Type2)
			{
				return element.FindResource("Type2") as DataTemplate;
			}
			return null;
		}
	}

Wie benutze ich das ganze in meiner XAML Datei?

In meiner XAML von meinem Window habe ich schon die DataTemplates unter <Window.Resources>
Es existiert nun in diesem Window ein TextBlock, der der die Daten darstellen soll.
Kannst du mir dazu ein Beispiel zeigen wie ich TextBlock + DataTemplate + Converter zusammen benutzen kann?

Hi,

ich versuche gerade sowas ähnliches zu implementieren.
Hast du eine Lösung zu deinem Problem gefunden?

Ich habe ebenfalls eine abstrakte Klasse und zwei Ableitungen. Pro Ableitung habe ich ein DataTemplate definiert.

Der Converter wird nun entweder ein Objekt vom Typ Ableitung1 oder Ableitung2 zurückgeben.

Das jeweilige DataTemplate müsste doch hier eingreifen und aus diesem Objekt was "vernünftiges" für den TextBlock erzeugen, damit was dargestellt werde kann.

Wenn der Converter einfach nur einen String zurücliefert, kann ich es anzeigen.
Das ist aber nicht das was ich möchte. Es soll diese konkreten Objekte zurückliefern und das jewilige DataTemplate soll sich darum kümmern, dass ich am Ende was sinnvolles für den TextBlock in der Hand habe.

Warum muss eigentlich die Managed C++ Methode in eine Klasse verpackt werden?
Ist dies zwingend notwendig?

Ich habe mal soeben, statt einen Verweis auf das Projekt die DLL direkt als Verweis eingebunden. Hierbei kommt es nicht zu der Fehlermeldung aber die Methode wird trotzdem nicht aufgerufen.

Dependency walker zeigt mir auch keine Methode an.

Hi,

habe nun daraus eine Klasse gemacht.
Wenn ich aber versuche, die DLL via Verweis einzubinden meckert VS
Da die folgende Situation vorliegt:

ProjektA(DLL) hat einen Verweis auf ProjektB
ProjektB braucht nun einen Verweis aus ProjektA(DLL)

Hierbei kommt die Meldung:

"A reference to 'SampleProject' could not be added. Adding this project
as a reference would cause a circular dependency."

Hi,

ich habe eine Managed C++ DLL, die die folgende Methode bereitstellt:

using namespace System;
using namespace MyCustomNamespace;
...
void DoSth(String ^first, String ^second, MyCSharpClass ^third);

Die MyCSharpClass ist in MyCustomNamespace enthalten.

Wenn ich nun versuche in meinem C# Projekt auf die Methode DoSth(..)
zuzugreifen, erhalte ich die obige Exception.
Wenn ich versuche, das Managed C++ Projekt als Referenz
in das C# Projekt einzubinden, erhalte ich

"A reference to 'SampleProject' could not be added. Adding this project
as a reference would cause a circular dependency."

In der selben Managed C++ DLL gibt es eine andere Methode TuWas(..), die ich mit __declspec(dllexport) exportieren konnte. Diese kann ich via Dependency Walker
sehen, jedoch nicht die DoSth.

Wenn ich es mit DoSth(..) versuche erhalte ich die Meldung:

__declspec(dllexport) cannot be applied to a function with the __clrcall calling convention

Wer kann mir helfen?

@herbivore

deinen Wrapper habe ich total vergessen, sorry.
Hattest es mir zuvor in dem anderen Beitrag vorgestellt. 👍

Danke

Ach verdammt. Das ist aber blöd.

Und was ist wenn ich statt Interface eine abstrakte Klasse benutze?

Die eigenliche Idee:
Ich will die Liste von außerhalb iterierbar machen.
Sollte ich da lieber IEnumerable zurück liefern?

Auf die Liste sollte man nur lesend zugreifen, deswegen IEnumerable oder ReadOnlyCollection.
Wenn man auf ein Element zugreift,..soll man natürlich auch das Element nicht verändern können. Deswegen statt B das Interface IB.

Hi,

ich stehe gerade vor einem Problem, wo ich nicht weiterkomme.

Ich habe die folgende Klasse:

class A
{
List<B> m_myList = new List<B>();
}

Die Klasse B implementiert das Interface IB.
Klasse A soll nun über eine Methode die Attribute m_myList zur Verfügung stellen aber als List<IB> und nicht als List<B>.

Die Klasse A stellt eine Methode wie diese zur Verfügung:

public ReadOnlyCollection<IB> GetMyList()
{
return new ReadOnlyCollection<IB>(m_myList);
}

So wie es oben steht, ist es anscheinend nicht in ordnung.
Was muss ich hier machen, damit es funktioniert?

m_myList auf List<IB> casten hat auch nicht viel gebracht.

"Eine Konvertierung.....ist nicht möglich"

Edit:
Die GetMyList() sollte am besten ReadOnlyCollection<IB> statt List<IB> zurückliefern. Vermute mal, dass es nicht so ein großer Unterschied ist, d.h. wenn das eine geht, geht auch das andere.

Hey aus reiner neugier:

Was sind eigentlich die Argumente die gegen das Kopieren sind?
Mir fällt spontan nur die Datenverdopplung ein. Was ist wenn man sagt, dass die Performanz der Anwendung nebensächlich ist ? Dann fällt das Argument ja weg...

Würde mich freuen, wenn du mir paar Gründe nennen könntest, die gegen das Kopieren von Objekten sind.

hi ,

das Problem ist einfach, dass ich diese Entscheidung nicht alleine treffen kann. (Gruppenentscheidung).

Mir ist natürlich klar, dass es eine ziemlich unsaubere Lösung ist.
Was meine Kollegen abgeschreckt hat war die Tatsache, dass durch die Verwendung von Interfaces das ganze zu unübersichtlich sei. (Was meiner Meinung nach nicht so ist)

Zur Zeit denke ich einfach, dass ich alles via referenz übergebe und hoffe, dass keiner in den restlichen Modulen Blödsinn programmiert und ohne Erlaubnis Daten verändert.

Aus zeitlichen Gründen haben wir uns gegen den Schutz mit Interfaces entschieden.
Die einfachste Lösung, die uns einfiel war folgende:
Übergebe einfach alles was nicht geändert werden darf als Kopie. D.h. die Methode würde eine lokale Kopie erhalten und da (im schlimmsten Fall) seine Veränderungen durchführen.

Ist zwar etwas dirty, die ganze Zeit Daten hin und her zu kopieren,..aber naja...
Wenn man sie nicht auf die schnelle anders schützen kann 😃.....

Dann habe ich aber gelesen, dass man in C# zwischen zwei Typen unterscheidet:
Referenz-Typen (class, interface,...) und Value-Typen (struct, int,....)

Wenn ich es richtig verstanden habe, kann ich von einer Instanz einer Klasse keine lokale Kopie in der Methode haben.

Nach einer Weile habe ich dann herausgefunden, dass meine Klasse einfach ICloneable
implementieren muss. Durch die Methode Clone() wird gewährleistet, dass eine Kopie übergeben wird.

Die Kopie ist aber wiederum vom selben Typen.
Das Problem, dass ich bei der ganzen Sache sehe ist :

MeineSchöneMethode(meinObjekt.Clone());
oder
MeineSchöneMethode(meinObjekt);

Beide Aufrufe wären ja gültig, da beide Objekte vom selben Type sind. Ich befürchte, dass derjenige der diese Methode aufruft möglicherweise vergessen kann die Clone() Methode aufzurufen und damit das Original Objekt übergeben wird.

Soo...
Stimmt das so?

Edit:
@herbivore

Danke für die Hinweise. Werde mir mal deine Links anschauen.

Danke,

zufälligerweise habe ich gerade den selben Code gefunden 😃

Werde mich mal etwas mit der Materie beschäftigen.

Danke dir für die Mühe

Existiert sowas auch für die anderen Container wie z.B. Dictionary?
Beim überfliegen konnte ich nichts für die anderen Container finden.

Das klingt schon einmal interessant.
Wie ich sehe muss derjenige, der die Liste übergeben möchte immer eine Kopie der original Liste erstellen bevor er sie via Parameter übergeben kann.

        List<string> dinosaurs = new List<string>();

        dinosaurs.Add("Tyrannosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Deinonychus");
        dinosaurs.Add("Compsognathus");

        ReadOnlyCollection<string> readOnlyDinosaurs = 
            new ReadOnlyCollection<string>(dinosaurs);

Wird da intern wirklich eine 1:1 Kopie erstellt? Das wäre ziemlich schlecht aus der Sicht der Performanz.

Mal abgesehen von C# Container Klassen. Die Idee mit den Interfaces, ließe sich doch auf eigene Klassen umsetzen oder?

Hi,

die meisten von euch haben sicherlich sofort erkannt, dass ich aus der C++ Welt komme. 😉
Mir ist auch klar, dass C# von Haus aus keine Mittel bietet um Objekte zu schützen, die als Parameter übergeben wurden. ( const reference in C++)

Jedoch habe ich in diversen Foren gelesen, dass man sowas ähnliches mit Interfaces
umsetzen kann.
D.h. wenn ich ein Objekt der Klasse X der Methode Y via Parameter übergeben möchte, muss ich für die Klasse X ein Interface I bereitstellen, was nur "Getter" Methoden kennt.

So wird die Methode Y nur diese Getter-Methoden sehen und wird
deswegen mein Objekt nicht verändern können.

Was ist nun wenn als Parameter eine C# eigene Klasse übergeben wird.
z.B. List<String> ?

Die erste Idee die mir einfiel war folgende:

List implementiert doch das Interface IList!
Wenn ich nun ein eigenes Interface "IMeinInterface" schreibe, was wiederum das Interface "IList" verwendet(ableitet?), müsste das doch umsetzbar sein?
Mein Interface müsste die ganzen "Setter" Methoden aus IList überdecken/ausschalten und nur Getter anbieten.

Meine Methode "MeineSchöneNeueMethode" würde als Parameter mein Interface IMeinInterface erhalten

MeineSchöneNeueMethode(IMeinInterface if);

Der Aufrufer meiner Methode würde folgendes machen:

List<String> meineListe = new List<String>();
meineListe.Add("blaaa");
MeineSchöneNeueMethode(meineListe);

In meiner Methode "MeineSchöneNeueMethode" kann ich nun auf die Liste lesend zugreifen, da mir durch das Interface nur bestimmte Sachen zur Verfügung gestellt werden.

Ich hoffe ihr blickt durch mein Gedankenspiel durch und könnt mir einen Ratschlag geben.

Hi,

erstmal danke für die Antworten.
Ich compiliere es schon mit /unsafe .

Hier habe ich noch etwas gefunden:

Pointers to Structures:

As previously mentioned, you can define a pointer to a structure, but you have to make sure that there are no reference types in the structure, for example, consider the example code below:

  
class TestClass  
{  
    . . .  
}  
  
struct TestStruct  
{  
    public int age;  
    public TestClass test;  
}  
  

You would not be able to then do the following:

  
TStruct test_struct;  
TStruct* struct_ptr;  
struct_ptr = &test_struct;  
  

When compiling this code, you would receive the error message:

Cannot take the address of, get the size of, or declare a pointer to a managed type.

Anscheinend kann ich in der Struktur nur Datentypen wie int, char* unterbringen. ??!?

Warum?

Hi,

beschäftige mich mal wieder nach langer Zeit mit C#.
Habe gerade ein Problem, wo ich keine Lösung finden kann.

namespace XY
{
	struct ZZ
	{
		public GString a;    // Typ von GTK-Glib
		public GString b;
	}
	
	public class Util
	{
		public Util()
		{
		}
		
		unsafe public ZZ* GetPtr()
		{
			
			return null;
		}
     }
}		

Beim compilieren bekomme ich die folgende Meldung:

Cannot take the address of, get the size of, or declare a pointer to a managed type (CS0208)

Warum kann ich meine Struktur nicht so aufbauen?
Oder anders gefragt, was muss ich ändern um doch so einen Strukturaufbau benutzen zu dürfen.

Hi & danke für die Antwort,

Ja die Gruppen haben unterschiedliche Typen.
Gibt es da was ich beachten muss?

Ich erkläre nochmal was ich vor hab, vielleicht gibt es da eine einfachere Lösung:

Im Forest haben wir mehrere Domänen.
Mir liegen Usernames vor, womit ich die User finden muss damit ich an deren Properties rankomme, in meinem Fall die Gruppenzugehörigkeiten.
Ich weiss jedoch nicht in welcher Domäne der jeweilige User steckt.

Über den Global Catalog finde ich mit einer Abfrage den jeweiligen User, aber mit den Properties gibt es das obige Problem.

Wenn ich das User-Objekt über GC ermittle,..beinhaltet die Gruppen-Liste weniger Einträge als wenn ich direkt eine LDAP Abfrage an die jeweilige Domäne absetze.

Gruß,

ThaMubber

Hallo zusammen,

Ich schreibe gerade eine Anwendung welches die Gruppenmitgliedschaft ("MemberOf") von bestimmten Usern im AD herausfinden muss.

Vorgehensweise:

DirectoryEntry vom User finden:

DirectorySearcher dirS = new DirectorySearcher();
1*) dirS.SearchRoot = new DirectoryEntry("LDAP://dc=domäne");
oder
2*) dirS.SearchRoot = new DirectoryEntry("GC://forest");

dirS.Filter = "(&(objectCategory=User) (samAccountName=" + username + "))";
result = dirS.FindOne();
..
entry = result.GetDirectoryEntry();

Hiermit bekomme ich meine UserObjekte anhand der Benutzernamen.

Mitgliedschaft holen:

IdentityReferenceCollection SidColl;
String[] tokgrp;
tokgrp = new String[] { "tokenGroups" };

entry.RefreshCache(tokgrp);

foreach (byte[] sidBytes in entry.Properties["tokenGroups"])
{
       SidColl.Add(new SecurityIdentifier(sidBytes,0));
}

Nun zu meinem Problem:

Wenn ich die ganze Suche im Global Catalog (2*)durchführe bekomme ich bei User XY 8 Gruppenmitgliedschaften.

Wenn ich es aber mit einer LDAP Abfrage (1*) durchführe bekomme ich alle , in diesem Fall knapp 17, Gruppenmitgliedschaften.

Warum?

Im Prinzip müsste doch dasselbe Ergebnis zurückgelieftert werden oder?

Gruß

thamubber