Forenbeiträge von Caveman Ingesamt 187 Beiträge
Hallo,
ich habe eine Konsolenanwendung, deren Aufruf aktuell durch Erstellen von ProcessStartInfo und Process.Start() sequentiell in einer Schleife abgearbeitet wird.
Ich möchte diese Aufrufe der Konsolenanwendung gerne Parallelisieren, so dass alle Kerne mit Arbeit versorgt werden.
Kann ich die vorhandenen Aufrufe mittels ProcessStartInfo und Process.Start() einfach in ein Parallel.ForEach packen, wie im folgenden Schnipsel?
public static void ExecuteParallel(List<ProcessStartInfo> processStartInfoCollection)
{
Parallel.ForEach(processStartInfoCollection, processStartInfo =>
{
using (Process process = Process.Start(processStartInfo))
{
process.WaitForExit();
}
});
}
Hallo,
in einem kleinen Testprojekt, in dem ich mit WPF und MVVM mit dem Datagrid experimentiere, ist die ItemsSource an eine ObservableCollection gebunden. Die Daten werden angezeigt und ich kann mit Klicken auf die Spaltenköpfe die Daten auch sortieren.
Ich kann aber jetzt nichts dazu finden, wie ich die sortierte Reihenfolge wieder in die ObservableCollection bekomme, um diese Sortierte Reihenfolge meinetwegen in einer Textdatei zu speichern. Es gibt die Property SortedDescriptions. Darin ist der ausgewählte Spaltenname des Datagrids und die Sortierreihenfolge hinterlegt.
Wie komme ich an die sortierte Collection ran?
@gfoidl: Ich denke, das ist nicht das was ich brauche.
Ich bin mittlerweile auf den Projekttyp SharedProject gestossen. Das könnte das sein, was ich suche. Muss ich bei Zeiten mal nach Beispielen und Informationen im Netz suchen!
Hallo zusammen,
für ein bestimmtes Programm habe ich mir diverse Erweiterungen programmiert. Nun ist es aber so, dass dieses Programm mittlerweile in mehreren Versionen verfügbar ist. Jede Version ist in einem eigenen Ordner auf der Festplatte installiert und jede Version nutzt seine eigenen DLLs, die ich in meinen Tools einbinden muss. Da ich bisher maximal 2 Versionen nutzte, habe ich in meinem Projekt die entsprechenden Verweise auf die DLLs immer gelöscht und danach neu eingebunden. Das wird mir jetzt aber zu lästig.
Deshalb wollte ich an dieser Stelle mal fragen, wie ich am besten mein Projekt in VS organisiere, so dass ich meine Erweiterung für die verschiedenen Programmversionen kompilieren kann.
Gibt es hierzu Fachbegriffe, mit denen ich Google befragen kann?
Danke!
Also das Beste was ich bisher zu WPF gelesen habe,
ist WPF-Das umfassende Handbuch
Ich musste ein halbes Jahr mit Pearl arbeiten.
Ich gebe zu: Es hat irgendwie Spaß gemacht
Aber auch nur, weil es heilloses Gefrickel war 😄
Jetzt schreibst Du schon wieder Pearl! 🤔
Meinst Du jetzt Perl - Die Sprache mit dem Kamellogo, die Larry Wall erfunden hat, oder PEARL (Process and experiment automation realtime language))
Du darfst aber auch nicht vergessen, dass Du in einigen Monaten oder Jahren im Extremfall genauso wenig über deine Anwendung weißt, wie ein potentieller Kollege, der sie noch nie gesehen hat 😜
Man sollte denke ich immer davon ausgehen, dass die Anwendung auch von jemand Anderem überarbeitet werden muss, einfach weil es hilft, den Code so zu schreiben, dass der (Wieder-) Einstieg später leichter ist.
Ich bin und bleibe der Einzige, der daran rumfingert. In meinem Umfeld kenne ich niemanden, der sich auch nur annähernd fürs programmieren interessiert. Deshalb bleiben mir auch nur Bücher, Foren und Google. Die Lernkurve ist demzufolge auch relativ flach!
Da ich mich bereits im fortgeschrittenen Alter befinde, weiß ich das sehr häufig schon zwei Wochen später gar nicht mehr! 😁
Da hast Du nun die Wahl:
Willst Du 16 Properties mit hoch gezähltem Namen haben, oder
Willst Du eine Property mit Array haben?
Ich würde zu Letzterem tendieren.
Man soll ja mit Komposition arbeiten. Deshalb gibt es im Roboterobjekt eine Eigenschaft
public override List<KukaTool> Tools { get; set; }
Allerdings: Wenn Du diese Daten gar nicht brauchst, musst Du sie auch nicht raus lesen.
Wenn Du später aber fest stellst, dass Du sie doch brauchst, dann hast Du Spaß, das zu ergänzen, oder alles umzubauen 😉
Ja, dessen bin ich mir bewußt. Aber Strafe muß sein und Übung macht den Meister.
... bei Sprachen wie PHP, Pearl, JavaScript, etc. (nichts gegen Entwickler aus dem Bereich). ...
Du meinst sicher Perl - Practical Extraction and Reporting Language. Das ist eine der coolsten Sprachen überhaupt!
... Aber es ist (denke ich) nachvollziehbar. ...
Ja, ist nachvollziehbar. Aber ausser mir wird da nie jemand anders Hand anlegen! Und für mich geht es in allererster Linie um den Lerneffekt.
... Auf den zweiten Blick (so ab Hälfte) sieht das wie eine Art Script aus, sehe ich das richtig?...
Nein, das ist eine reine Konfigurationsdatei. Mich interessiert aber nicht alles, was in der Datei steht.
Ganz ganz "einfach" gedacht:
Du hast einen Kontext mit einen Dictionary<string, VariableEntry> für die Variablen-Werte
Dieser Kontext hat viele Operationen, wie CreateVariable() und GetVariable()
Dazu gibts ein Interface IOperation mit einer Methode Execute(Kontext)
Und an dritter Stelle brauchst Du ein System, was den String parsed und anhand dessen bestimmt, welche der Operationen das ist, das Objekt dazu erstellt und mit den Inhalten der Zeile füttert.
Anschließend hast Du eine Liste von Operationen, die Du nacheinander auf den selben Kontext ausführst.
DANACH hast Du ein Kontext-Objekt mit Werten, aus denen Du dann ein Ergebnis-Objekt bauen kannst.
Bei so einer oder so ähnlichen Herangehensweise kommst Du die meiste Zeit ohne Reflection aus, der Teil, der tatsächlich mit Reflection arbeitet hat eine sehr einfach und klar definierte Aufgabe: Schreibe Variablen-Wert vom Kontext in Property von Objekt.
Zumindest, wenn ich nicht völlig daneben liege 😄
Hier wirft mein Betriebssystem eine FailedToUnderstandException 😉
Ich werde das jetzt mit Reflection weiter verfolgen. Scheint mir am einfachsten zu sein.
Als Ergänzung hier noch meine definierten Klassen. Im Summary steht dann, was da rein soll.
public class KukaTool
{
/// <summary>
/// Index von TOOL_DATA, TOOL_NAME oder TOOL_TYPE
/// </summary>
public int Number { get; set; }
/// <summary>
/// Der Name von TOOL_NAME[1,]="Toolname 1"
/// </summary>
public string Name { get; set; }
/// <summary>
/// TOOL_DATA[1]={X 0.0,Y 15.0000,Z 404.000,A 0.0,B 0.0,C 0.0}
/// </summary>
public KukaFrame Location { get; set; }
/// <summary>
/// Der Typ von TOOL_TYPE[1]=#BASE
/// </summary>
public Enums.KukaFrameType Type { get; set; }
}
public class KukaFrame
{
public double X { get; set; }
public double Y { get; set; }
public double Z { get; set; }
public double A { get; set; }
public double B { get; set; }
public double C { get; set; }
}
Du zitierst nun nicht wirklich ein Lehrbuch von >2001< - oder?
Nein, aus 2009!
Und wenn dir ein "Lehrbuch" pauschal von Interfaces abrät, solltest du das ganz weit wegwerfen.
Nicht pauschal!
Das "Lehrbuch" ist übrigens von B. Abrams und K. Cwalina
Aber bitte zurück zum Thema. Wir sind schon ganz weit Offtopic!
Ich wollte schon gestern fragen, wie so eine Datei aussieht und ob er eine Beispiel-Datei anhängen kann, dann sieht man sofort wo der Hase hinläuft...
Ich habe mal eine konkrete Datei angehängt. Die Endung ist .dat
Diese Verteufelung von Reflection kann ich ehrlich gesagt nicht nachvollziehen.
Jede CSV-Library arbeitet mit Reflection, zumindest sobald sie die Daten auch gegen eine Klasse mappt.
Das gleiche gilt für jede XML-Library (und JSON), jedes ORM, etc.
Sobald irgendwelche Werte anhand von String-Keys gegen ein Objekt gemapped werden sollen, ist Reflection im Spiel und das aus gutem Grund.
Es ist leider nicht nur mit Reflection so. Gleiches gilt z.B. auch beim Thema Schnittstellen. Der eine sagt, man soll auf Schnittstellen programmieren, der andere sagt nein. Hab mir auch das Buch "Framework Design Guidelines" für mein Vorhaben zugelegt. Da wird im Übrigen auch von Programmierung auf Schnittstellen abgeraten. Aber keiner sagt WARUM!
Und das ist auch für mich eines der größten Probleme hier in diesem Forum. Viele hier haben anscheinend keine Ahnung, mit was für Problemen wir Programmieramateure uns rumschlagen müssen. Was soll ich davon halten, wenn zig verschiedene Meinungen zu einem simplen Problem vorgetragen werden? Ich weiß jetzt z.B. immer noch nicht, warum Reflection zu 99% falsch sein soll!
Ich tippe mal darauf, dass Caveman irgendein Datenformat hat, was keinem gängigen Format wie CSV oder XML folgt, ein vorhandenes Framework kann er also nicht verwenden.
Dieses Format will also gelesen werden und die Daten sollen am Besten in einer Klasse mit Properties landen.
Im schlimmsten Fall gibt es sogar viele verschiedene Dateien, die zwar dem selben Format folgen, aber unterschiedliche Keys haben.
Wir wissen ja auch nicht, ob das gezeigte Beispiel wirklich das echte Format ist, das kann ja noch weit komplexer sein.
Genau so ist es! Vielen Dank für Deine Worte!
Ich persönlich würde in so einem Fall - wenn ich wirklich viele verschiedene Dateien mit dem gleichen Format habe - ein kleines Mini-Framework bauen, was anhand eines einfachen Mappings (Key zu Property) die Inhalte lesen kann. Oder ein automatisches Mapping anhand der Property-Namen (oder ein KeyNameAttribute), was viel Schreibarbeit spart.
Das mag dann zwar komplett auf Reflection aufbauen, dafür ist der Code überschaubar, flexibel wiederverwendbar und der Aufrufer bekommt das denkbar einfachste Ergebnis zurück: Ein Objekt der gemappten Klasse mit typisierten Properties, wie er sie braucht.
Genau das ist mein Vorhaben! Und es ist mittlerweile auch schon mein vierter Versuch X(
Reflection ist zu 99% die falsche Lösung.
Beschreibe lieber mal was du erreichen möchtest, ...
Ist das aus dem Eingangspost nicht ersichtlich?
Wenn nein, welche Infos fehlen denn dann noch?
Und warum soll Reflection nun schon wieder der falsche Weg sein?
In dem Fall könnte sich Reflection anbieten. Stichwort: PropertyInfo.SetValue
Falls der Name (im String) nicht 1:1 dem Eigenschaftsnamen entspricht, könntest du auch noch eine Mapping-Tabelle benutzen.
Ich habe mich jetzt in das Thema Reflection etwas eingelesen und es ist genau das, was ich gesucht habe.
Vielen Dank nochmals Th69 für den Tipp!
Nun ja, vielleicht soll ich doch noch etwas mehr erzählen!
Nach mehreren Jahren der mühevollen Einarbeitung in C#, Objektorientierung, Frameworkdesign usw. habe ich für mich erneut entschieden, ein kleines Framework für Industrieroboter zu programmieren. Für den Anfang sollen die Roboter von Kuka, ABB und Fanuc realisiert werden.
Die Daten kommen aus den Roboterbackups.
Das erste Ziel sollte sein, aus den Backups ein Robotermodell zu bauen.
Das kann dann wiederum verwendet werden, um verschiedene Parameter zu dokumentieren.
Außerdem will ich zu einem späteren Zeitpunkt noch versuchen, Programme von einer Steuerung auf eine andere Steuerung zu transformieren.
Ob mir das alles gelingt weiß ich nicht. Es ist aber nicht mein erster Versuch in dem Thema X(
Danke, das mit Reflection werde ich heute Abend nach der Arbeit mal ausprobieren.
Dictionaries hatte ich auch schon probiert. Diese helfen mir aber für zukünfige Aufgaben nicht weiter - denke ich zumindest aktuell!
Hallo,
es geht darum, dass ich eine Textdatei parsen, und die verschiedenen enthaltenen Datenformate in Klassen darstellen möchte.
Die Klassen habe ich bereits erstellt. Die Schwierigkeit ist nun, den String in die Klasse zu überführen.
In dem Beispiel habe ich nur drei Paare dargestellt. Es können aber auch sechzehn Paare sein. Dann wird es schon lästig, mit if-Abfragen zu arbeiten.
Der einfachste Weg mit
class1.value[0] = value
funktioniert leider nicht!
Hallo,
ich habe mal wieder eine Anfängerfrage.
Es geht darum, wie ich am effektivsten einen String in die Eigenschaften einer Klasse überführt bekomme.
Meine derzeitige Lösung sieht ungefähr so aus:
public class Class1
{
public double Key1 { get; set; }
public double Key2 { get; set; }
public double Key3 { get; set; }
}
public class Class2
{
public Class1 Convert()
{
string stringToConvert = "Key1 Value1, Key2 Value2, Key3 Value3";
string[] pairs = stringToConvert.Split(',');
Class1 class1 = new Class1();
foreach (string pair in pairs)
{
string[] values = pair.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
double value = double.Parse(values[1]);
if(values[0].Equals("Key1"))
{
class1.Key1 = value;
}
else if (values[0].Equals("Key2"))
{
class1.Key2 = value;
}
else if (values[0].Equals("Key3"))
{
class1.Key3 = value;
}
}
return class1;
}
}
Meine Frage zielt auf die if-Abfragen ab. Gibt es da einfachere Möglichkeiten, eine Verbindung zwischen Key<x> des Strings und Key<x> der Eigenschaft von Class1 herzustellen?
Guten Tag!
Ich bin gerade dabei, mich mit Komponententests zu beschäftigen. Dazu habe ich mir eine Projektmappe mit zwei Projekten angelegt. Eine .Net Klassenbibliothek und ein Komponententest-Projekt.
Eine erste Testmethode soll einfach nur den Konstruktor in der Klassenbibliothek prüfen.
Jedoch werden mir keine Testergebnisse im Testexplorer angezeigt. Es erscheint immer nur der Text "Erstellen Sie Ihr Projekt, um alle verfügbaren Tests zu ermitteln. ..."
Nach einigem Probieren habe ich jetzt festgestellt, dass wohl der Projektort der Grund für das "Fehlverhalten" ist.
Wenn ich das Projekt auf meinem Netzwerklaufwerk ausführe, dann funktioniert es nicht.
Auf einem lokalen Laufwerk funktioniert es.
Kann man in VS2017 das so einstellen, dass dies auch auf Netzlaufwerken funktioniert?
[Edit] Ich habe die nötige Einstellung gefunden.
In einer Entwickler-Eingabeaufforderung muss folgendes eingegeben werden:
setx COMPLUS_LoadFromRemoteSources 1
Das Fehlverhalten scheint schon ziemlich lange bekannt zu sein. Wurde schon mit der 2010er Version festgestellt.
Ich vermute mal ganz startk, dass der catch-Block ausgeführt wird, wenn auf eine Leere Zelle zugegriffen wird.
Danach der finally-Block und Ende.
Setze doch mal einen Breakpoint im inneren Catch-Block bei der throw-Anweisung.
Eine Reparaturinstallation habe ich schon versucht.
Ohne Erfolg!
Vielleicht liegt es auch nur an diesem ASP.Net Paket. Nur weiß ich nicht, wie ich das los werde.
Unter der Systemsteuerung wird mir in der Programmliste nichts angezeigt, was drauf hinweisen würde. Mich macht es etwas stutzig, dass bei dem ASP-Paket 2015.1 angezeigt wird. Ich hatte VS2015 mit Update 3 installiert.
Hallo,
heute habe ich mir das Visual Studio 2017 Pro gegönnt!
Jetzt will ich das Visual Studio 2015 deinstallieren, was nicht so recht klappen will.
Es kommen ständig die gleichen Fehler - siehe Bild.
Über eine Microsoft Seite bin ich auf den TotalUninstaller aufmerksam geworden. Aber auch dieser schafft es nicht, VS2015 restlos von der Platte zu putzen.
Hat von euch jemand einen Geheimtipp?
Guten Tag!
Ich habe ein Datagrid mit einer TextColumn und mehreren CheckBoxColumns.
In der TextColumn soll die Anzahl der selektierten Checkboxen in einer Datenzeile angezeigt werden.
Ich war der meinung, dass ich das mit dem Event CellEditEnding bewerkstelligen könnte. Allerdings ist der Zellenwert beim Auslösen des Ereignisses noch nicht übernommen.
Ich habe nun probiert und probiert, aber finde keinen Lösungsansatz.
Das Event CurrentCellChanged funktioniert nur, wenn ich in der gleichen Datenzeile bleibe.
Wie kann ich mein Problem lösen?
Hierzu noch mein derzeitiger Code.
´ private void OnCellEditEndingExecuted(object obj)
{
if (obj == null) return;
DataGridCellEditEndingEventArgs eventArgs = obj as DataGridCellEditEndingEventArgs;
DataRowView rowView = eventArgs.Row.Item as DataRowView;
GroupUserCount numbers = getCountedUsersInGroup(rowView.Row[1].ToString());
numbers.Selected = 0;
for (int columnIndex = 2; columnIndex < rowView.Row.ItemArray.Count(); columnIndex++)
{
bool isSelected;
string cellValue = rowView.Row.ItemArray[columnIndex].ToString();
if (bool.TryParse(cellValue, out isSelected))
{
if (isSelected)
{
numbers.Selected++;
}
}
}
rowView.Row.Table.Columns[1].ReadOnly = false;
rowView.Row[1] = string.Format(maxUserFormat, numbers.Selected, numbers.Maximum);
rowView.Row.Table.Columns[1].ReadOnly = true;
}
<DataGrid x:Name="optionsDataGrid" AutoGenerateColumns="True" AlternatingRowBackground="Silver" ItemsSource="{Binding UserToGroupAssignments}" CanUserDeleteRows="False" CanUserAddRows="False" VerticalContentAlignment="Center" CanUserReorderColumns="False" CanUserSortColumns="False" CanUserResizeColumns="False" CanUserResizeRows="False" IsSynchronizedWithCurrentItem="True" SelectionUnit="Cell" >
<interact:Interaction.Triggers>
<interact:EventTrigger EventName="CellEditEnding">
<mvvmlight:EventToCommand Command="{Binding CellEditEnding}" PassEventArgsToCommand="True" />
</interact:EventTrigger>
</interact:Interaction.Triggers>
<DataGrid.ColumnHeaderStyle>
<Style TargetType="DataGridColumnHeader">
<Setter Property="Background" Value="LightBlue" />
<Setter Property="FontWeight" Value="Bold" />
<Setter Property="HorizontalAlignment" Value="Stretch" />
<Setter Property="HorizontalContentAlignment" Value="Center" />
<Setter Property="VerticalAlignment" Value="Center" />
<Setter Property="BorderBrush" Value="Black" />
<Setter Property="BorderThickness" Value="1" />
<Setter Property="Padding" Value="5,0" />
</Style>
</DataGrid.ColumnHeaderStyle>
<DataGrid.CellStyle>
<Style TargetType="DataGridCell">
<Setter Property="VerticalAlignment" Value="Stretch" />
<Setter Property="VerticalContentAlignment" Value="Stretch"/>
</Style>
</DataGrid.CellStyle>
</DataGrid>
Ich glaube, dass ich meine Lösung gefunden habe.
Mit
table.Columns[i].SetOrdinal(columnIndex);
kann man die Spalten der DataTable neu "organisieren". Jetzt muss ich nur noch schauen, wie ich das umsetze. Eventuell in einer Erweiterung (nur damit ich das auch mal gemacht habe 🙂)
Hallo!
In einem UserInterface habe ich ein DataGrid in welchem sich die Spalten verschieben lassen.
Bei der Serialisierung in ein XML-File wird das DataGrid in eine DataTable geschrieben und dann gespeichert. Allerdings immer nur in der Reihenfolge wie die Spalten erstellt wurden. Eine geänderte Spaltenreihenfolge bleibt unberücksichtigt.
Wie kann ich eine geänderte Spaltenreihenfolge in die XML-Datei schreiben?
So etwa?
namespace Interface_01_Math_auslagern_WFA
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void CMD_Close_Click(object sender, EventArgs e)
{
Close();
}
private void CMD_ADD_Click(object sender, EventArgs e)
{
double V_E_1 = Convert.ToDouble(E_1.Text);
double V_E_2 = Convert.ToDouble(E_2.Text);
double V_E_3 = Convert.ToDouble(E_3.Text);
double V_E_4 = Convert.ToDouble(E_4.Text);
double Ergebniss_add = Add.Addieren(V_E_1, V_E_2, V_E_3, V_E_4);
LB_Info.Text = Convert.ToString(Ergebniss_add);
}
}
}
public static class Add
{
public static double Addieren(double W1, double W2, double W3, double W4)
{
double Ergebniss_add;
Ergebniss_add = W1 + W2 + W3 + W4;
return Ergebniss_add;
}
}
Hallo,
aufgrund dieses Threads habe ich mich nun mit OpenXml auseinandergesetzt und begonnen meine Tools von der Interop Technik nach OpenXml umzustellen.
Das funktioniert ganz gut und ist wahnsinnig schnell. Danke Abt für den Tipp! 👍
Nun habe ich aber ein Problem, was ich einfach nicht gelöst bekomme und auch den Grund nicht verstehe.
Folgende Methode erzeugt eine Exception in der Append-Methode, wenn der else if-Block ausgeführt wird. Die Exception lautet "Non-composite elements do not have child elements."
private void writeSheetHeader(ExcelHeaderOrientations orientation, List<string> headers)
{
if (orientation == ExcelHeaderOrientations.HORIZONTAL)
{
Row row = new Row();
for (int i = 0; i < headers.Count; i++)
{
row.Append(BuildCell(headers.ElementAt(i), CellValues.String));
}
WorksheetData.AppendChild(row);
}
else if (orientation == ExcelHeaderOrientations.VERTICAL)
{
Column column = new Column();
for (int i = 0; i < headers.Count; i++)
{
Cell cell = BuildCell(headers.ElementAt(i), CellValues.String);
column.Append(cell); // <--- erzeugt eine Exception
}
WorksheetData.AppendChild(column);
}
}
Ist es nicht möglich, eine Tabelle spaltenweise zu schreiben?
Alle Codebeispiele, die ich im Internet gefunden habe, schreiben immer zeilenweise.
Hallo,
ich versuche krampfhaft ein Datagrid zu bauen, bei der die Anzahl der Spalten variabel ist. Ein Beispiel als Bildanhang. Die Spalte "Pose name" ist immer vorhanden. Der Yx Spalten sind variabel und werden in einem anderen Datagrid definiert.
Ich habe größte Probleme, die variablen Spalten darzustellen. Das betrifft sowohl den Spaltenkopf als auch die Zellen.
Deshalb möchte ich hiermit um etwas Hilfe/Unterstützung bitten.
Hier mein derzeitiger Arbeitsstand:
Die Spaltenüberschriften werden jetzt der Einfachheit halber im Konstructor vom ViewModel erzeugt.
Die View:
<DataGrid Margin="0,30,0,0" Grid.Row="3" AutoGenerateColumns="False" AlternatingRowBackground="Silver" ItemsSource="{Binding Poses}" >
<DataGrid.CellStyle>
<Style TargetType="DataGridCell">
<Setter Property="VerticalAlignment" Value="Stretch" />
<Setter Property="VerticalContentAlignment" Value="Stretch"/>
</Style>
</DataGrid.CellStyle>
<DataGrid.Columns>
<DataGridTextColumn Header="Pose name" Binding="{Binding Posename}" />
<DataGridTemplateColumn Width="auto">
<DataGridTemplateColumn.HeaderStyle>
<Style TargetType="DataGridColumnHeader">
<Setter Property="HorizontalContentAlignment" Value="Stretch" />
<Setter Property="VerticalContentAlignment" Value="Stretch" />
<Setter Property="Margin" Value="0" />
<Setter Property="ContentTemplate">
<Setter.Value>
<DataTemplate>
<ItemsControl ItemsSource="{Binding ValveNames}">
<ItemsControl.ItemsPanel>
<ItemsPanelTemplate>
<StackPanel Orientation="Horizontal">
</StackPanel>
</ItemsPanelTemplate>
</ItemsControl.ItemsPanel>
<ItemsControl.ItemTemplate>
<DataTemplate>
<Border Width="70" >
<TextBlock Text="{Binding}" TextAlignment="Center"/>
</Border>
</DataTemplate>
</ItemsControl.ItemTemplate>
</ItemsControl>
</DataTemplate>
</Setter.Value>
</Setter>
</Style>
</DataGridTemplateColumn.HeaderStyle>
<DataGridTemplateColumn.CellTemplate>
<DataTemplate>
<CheckBox IsChecked="{Binding Valves.Values, Mode=OneWay}" />
</DataTemplate>
</DataGridTemplateColumn.CellTemplate>
</DataGridTemplateColumn>
</DataGrid.Columns>
</DataGrid>
Das ViewModel:
public class RwCreateEpMainWindowViewModel : ViewModelBase
{
private ObservableCollection<RwEpPoseCreationData> poses;
private ObservableCollection<string> valveNames;
public ObservableCollection<RwEpPoseCreationData> Poses
{
get { return poses; }
set
{
if (poses != value)
{
poses = value;
OnPropertyChanged();
}
}
}
public ObservableCollection<string> ValveNames
{
get { return valveNames; }
set
{
if (valveNames != value)
{
valveNames = value;
OnPropertyChanged();
}
}
}
public RwCreateEpMainWindowViewModel()
{
Poses = new ObservableCollection<RwEpPoseCreationData>();
ValveNames = new ObservableCollection<string>() { "y1", "y2", "y3", "y4" };
}
}
Das Model:
public class RwEpPoseCreationData
{
public string Posename { get; set; }
public Dictionary<string, bool> Valves { get; set; }
public RwEpPoseCreationData()
{
Valves = new Dictionary<string, bool>();
}
}
Ich weiß zwar nicht, was Du genau vorhast, aber folgendes geht:
static void Main(string[] args)
{
int[] Array1 = { 1, 2, 3, 4, 5 };
int[] Array2 = { 6, 7, 8, 8, 0 };
Console.WriteLine(Methode(Array1, Array2));
Console.ReadKey();
}
static int Methode(int[] Methode1, int[] Methode2)
{
int i = 0;
return i;
}
Hallo Mossi,
es hat jetzt etwas gedauert, aber heute habe ich Deine Lösung endlich ausprobieren können.
Es wird ein Wert in die Registry geschrieben. Allerdings stimmt der nicht, denn es werden nochmals acht Nullen hinter dem eigentlichen Wert drangehängt.
Habe es deshalb jetzt mit Integer gemacht.
Vielen Dank jedenfalls für Deine Lösung!
Mir ist nicht bekannt, dass Inno eine eingebaute Funktion dafür hätte.
Warum nimmst Du keine For-Schleife?
Hier mal beispielhaft die Methoden zum Zeichnen der Rahmenlinien und zum Färben der Zellen.
protected void DrawTableBorders(Office.MsoLineDashStyle borderStyle, int borderWeight, Office.MsoTriState borderVisibility, Color borderColor)
{
int intBorderColor = BitConverter.ToInt32(new byte[] { borderColor.R, borderColor.G, borderColor.B, 0x00 }, 0);
for (int row = 1; row <= Table.Rows.Count; row++)
{
for (int col = 1; col <= Table.Columns.Count; col++)
{
Table.Cell(row, col).Borders[Powerpoint.PpBorderType.ppBorderTop].DashStyle = borderStyle;
Table.Cell(row, col).Borders[Powerpoint.PpBorderType.ppBorderTop].Weight = borderWeight;
Table.Cell(row, col).Borders[Powerpoint.PpBorderType.ppBorderTop].ForeColor.RGB = intBorderColor;
Table.Cell(row, col).Borders[Powerpoint.PpBorderType.ppBorderTop].Visible = borderVisibility;
Table.Cell(row, col).Borders[Powerpoint.PpBorderType.ppBorderBottom].DashStyle = borderStyle;
Table.Cell(row, col).Borders[Powerpoint.PpBorderType.ppBorderBottom].Weight = borderWeight;
Table.Cell(row, col).Borders[Powerpoint.PpBorderType.ppBorderBottom].ForeColor.RGB = intBorderColor;
Table.Cell(row, col).Borders[Powerpoint.PpBorderType.ppBorderBottom].Visible = borderVisibility;
Table.Cell(row, col).Borders[Powerpoint.PpBorderType.ppBorderLeft].DashStyle = borderStyle;
Table.Cell(row, col).Borders[Powerpoint.PpBorderType.ppBorderLeft].Weight = borderWeight;
Table.Cell(row, col).Borders[Powerpoint.PpBorderType.ppBorderLeft].ForeColor.RGB = intBorderColor;
Table.Cell(row, col).Borders[Powerpoint.PpBorderType.ppBorderLeft].Visible = borderVisibility;
Table.Cell(row, col).Borders[Powerpoint.PpBorderType.ppBorderRight].DashStyle = borderStyle;
Table.Cell(row, col).Borders[Powerpoint.PpBorderType.ppBorderRight].Weight = borderWeight;
Table.Cell(row, col).Borders[Powerpoint.PpBorderType.ppBorderRight].ForeColor.RGB = intBorderColor;
Table.Cell(row, col).Borders[Powerpoint.PpBorderType.ppBorderRight].Visible = borderVisibility;
}
}
}
protected void FillTableColors(List<Color> cellColors)
{
int col = 0;
for (int i = 0; i < cellColors.Count; i++)
{
col++;
if (cellColors.ElementAt(i) == Colors.Transparent) continue;
int intColumnColor = BitConverter.ToInt32(new byte[] { cellColors.ElementAt(i).R, cellColors.ElementAt(i).G, cellColors.ElementAt(i).B, 0x00 }, 0);
for (int row = 1; row <= Table.Rows.Count; row++)
{
Table.Cell(row, col).Shape.Fill.ForeColor.RGB = intColumnColor;
}
}
}
Momentan passiert das Einfärben der Tabelle über eine Liste mit Farben - ein Listeneintrag pro Tabellenspalte. Mit Colors.Transparent teile ich mit, dass die Zelle unangetastet bleiben soll. Man sieht an der Methode auch, dass hier immer komplette Spalten eingefärbt werden. Das ist für einen Tabellentypen geeignet. Aber es ist halt für die weiteren Tabellenformate ungeeignet. Ich suche also nach einer universelleren Lösung. Ziel sollte auch sein, dass man relativ leicht weitere Tabellenformate hinzufügen kann (in einem Jahr oder so).
.. und wieso nutzt Du nicht OpenXML?
Einfache Antwort. Ich wusste bis jetzt nicht, dass es das gibt.
Ich werde mal danach googeln.
Das liegt daran, dass ich mir zuerst mal nur allgemein gehaltene Antworten erhofft hatte.
Gut, bisher habe ich das so gemacht, dass ich je eine Methode für jede vorkommende Tabelle programmiert hatte. In dieser gibt es dann eine Aneinanderreihung von For- und Foreach-Schleifen für: Zellenbreiten, Zellenfarben, Vertikale Ausrichtung, Horizontale Ausrichtung, Rahmenlinien, usw.
Alles nicht schön! Aber da das mein erstes Projekt dieser Art war, war ich schon mal froh, dass ich es überhaupt hinbekommen hatte =)
Meine Überlegungen haben sich dahin verfestigt, dass ich z.B. eine Methode für die Einfärbung der Zellen habe. Die größte Schwierigkeit für mich ist jetzt, wie ich der Methode klarmache, welche Zellen einzufärben sind.
Hallo,
eine zweite Frage hinten nach.
In meiner Powerpoint-Anwendung werden Tabellen formatiert erstellt. Es gibt in der Anwendung derzeit vier verschiedene Tabellenformate.
Unterschiedliche Zellenfarben und unterschiedliche Textausrichtungen. Manche Zellen sind auch verbunden.
In meiner Ursprungsversion führte die Formatierung der Tabellen zu unübersichtlichem Spaghetti-Code.
Das will ich in meiner überarbeiteten Version vermeiden oder zumindest stark reduzieren.
Leider haben meine Ansätze in den letzten zwei Tagen keine nennenwerten Verbesserungen am Code zu Tage gebracht.
Wie sollte ich das am besten angehen, damit auch unterschiedliche Tabellenformate berücksichtigt werden?
Hallo,
ich bin dabei, ein Projekt mit automatischer Erstellung von Powerpointdateien, in ein anderes Projekt zu integrieren.
Bisher arbeitete die Anwendung "relativ" langsam, da Powerpoint dabei geöffnet war und man bei der Erstellung zusehen konnte. Das möchte ich nun optimieren indem ich die Dateien erstelle, ohne dass dabei Powerpoint geöffnet ist.
Dazu habe ich nun folgenden Code:
private Powerpoint.Application powerpoint;
private Powerpoint.Presentation presentation;
protected RwPowerpointApplication(bool visible) : this()
{
if (powerpoint != null)
{
if (visible)
{
powerpoint.Visible = Office.MsoTriState.msoTrue;
}
else
{
powerpoint.Visible = Office.MsoTriState.msoFalse;
}
}
}
protected void AddPresentation()
{
presentation = powerpoint.Presentations.Add(WithWindow: Office.MsoTriState.msoFalse);
}
Wenn ich nun an den Konstruktor ein false übergebe, dann öffnet Powerpoint und erstellt die Dateien, ohne dabei die Folie anzuzeigen. Verantwortlich dafür ist die Add-Methode, der ebenfalls ein false übergeben wird.
Übergebe ich an den Konstruktor ein false, dann funktioniert gar nichts mehr! Es wird aber auch kein Fehler oder eine Ausnahme erzeugt. Es passiert einfach nichts mehr.
Habe mal Google danach befragt, aber keine brauchbaren Antworten dazu gefunden.
Aber offenbar ist es so, dass Powerpoint in jedem Fall geöffnet sein muss, da viele Funktionen nur dann funktionieren.
Kann mir hier jemand mitteilen, was die Visible-Eigenschaften nun genau bewirken soll?
Hallo,
Danke für die Antworten.
Ja, die Dll ist in Windows\System32 vorhanden.
Inno-Setup kann jedenfalls damit umgehen. Das Problem ist nur, dass in der Code-Section als Rückgabewerte nur String und Boolean erlaubt sind.
Ich hatte gehofft, dass die Inno-Profis hier das auf den ersten Blick sehen.
Meine Lösung ist jetzt eine Konsolenanwendung, die in der Run-Section aufgerufen wird und den Wert in die Registry schreibt.
Habe nochmals in der Hilfe gelesen. Es werden in der Code-Section nur die Typen String und Boolean unterstützt.
Hallo,
ich versuche mit über ein Inno-Setup-Skript einen Unix-Timestamp in die Registry zu schreiben.
Leider scheitert das ganze aber offenbar an dem Aufruf der DLL.
Kann mir jemand sagen, was bei dem folgenden Code nicht funktioniert?
[Registry]
Root: "HKLM64"; Subkey: "SOFTWARE\Name\{#MyAppName}"; ValueType: qword; ValueName: "TStamp"; ValueData: "{code:GetUnixTimestamp(0)}"; Flags: createvalueifdoesntexist
[Code]
//Unix Timestamp
function GetUnixTimestamp(ATimerPtr: Int64): Int64;
external 'time@msvcrt.dll cdecl';
Ich habe den Code von StackOverflow und schon 1000 mal abgewandelt.
Ich habs mir schon gedacht, dass ich hier mit meinem Beispiel eins übergebraten bekomme 😁
Den Link zu async/await habe ich mir durchgelesen, muss aber gestehen, dass das im Moment Böhmische Dörfer für mich sind. Habs aber auch auf meine Liste gesetzt, die immer länger wird.
Da es in der Anwendung nur einmalig um die Aktualisierung einer ProgressBar geht, möchte ich es für den Anfang erstmal mit dem Backgroundworker versuchen.
Ich habe mein Beispiel modifiziert. Wäre es so akzeptabel?
using System;
using System.ComponentModel;
using System.Threading;
namespace TestProgressBar
{
class Program
{
static void Main(string[] args)
{
BackgroundWorker backgroundworker = new BackgroundWorker();
backgroundworker.WorkerReportsProgress = true;
backgroundworker.ProgressChanged += PrintProgress;
backgroundworker.DoWork += Run;
backgroundworker.RunWorkerAsync();
Console.ReadKey();
}
private static void PrintProgress(object sender, ProgressChangedEventArgs eventArgs)
{
Console.WriteLine(eventArgs.ProgressPercentage.ToString());
}
private static void Run(object sender, DoWorkEventArgs e)
{
ForegroundWorker foregroundworker = new ForegroundWorker();
foregroundworker.WorkToDo(sender);
}
}
class ForegroundWorker
{
public ForegroundWorker()
{
}
public void WorkToDo(object sender)
{
for (int i = 1; i <= 100; i++)
{
(sender as BackgroundWorker).ReportProgress(i);
Thread.Sleep(500);
}
}
}
}
Hallo,
ich habe eine kleine WPF-Anwendung geschrieben, in der Exceltabellen eingelesen und die Daten in einem Datagrid angezeigt werden.
Je nach Größe der Exceltabelle dauert das seine Zeit.
Deshalb habe ich mir gedacht, ich implementiere in der View eine ProgressBar, die mir den Fortschritt anzeigt. In dem ViewModel wird eine Backgroundworker-Instanz erstellt und eine entsprechende Property für die ProgressBar in der View beschrieben. Die eigentliche Arbeit ist in einer separaten Klasse ausgelagert und ich weiß jetzt nicht so recht, wie ich die entsprechende Methode für DoWork aufrufen soll.
Zum Rumprobieren habe ich mir ein kleines Projekt angelegt, in dem ich den Backgroundworker als Verweis an die entsprechende Klasse weiterleite.
Der Code funktioniert soweit.
Nur ist diese Vorgehensweise richtig? Wie kann es anders oder besser gemacht werden?
using System;
using System.ComponentModel;
using System.Threading;
namespace TestProgressBar
{
//ViewModel
class Program
{
static void Main(string[] args)
{
BackgroundWorker backgroundworker = new BackgroundWorker();
backgroundworker.WorkerReportsProgress = true;
backgroundworker.ProgressChanged += PrintProgress;
ForegroundWorker foregroundworker = new ForegroundWorker(ref backgroundworker);
Console.ReadKey();
}
private static void PrintProgress(object sender, ProgressChangedEventArgs eventArgs )
{
Console.WriteLine(eventArgs.ProgressPercentage.ToString());
}
}
//Read an Excel file
class ForegroundWorker
{
public ForegroundWorker(ref BackgroundWorker backgroundworker)
{
backgroundworker.DoWork += WorkToDo;
backgroundworker.RunWorkerAsync();
}
public void WorkToDo(object sender, DoWorkEventArgs e)
{
for (int i = 0; i < 100; i++)
{
(sender as BackgroundWorker).ReportProgress(i);
Thread.Sleep(800);
}
}
}
}
Hallo,
ich versuche gerade mit Win32_DeviceChangeEvent bzw. Win32_VolumeChangeEvent das Hinzufügen von neuen Laufwerken zu protokollieren.
Dazu habe ich jetzt folgenden Code:
using System;
using System.Linq;
using System.IO;
using System.Management;
namespace DriveInfos
{
class Program
{
static void Main(string[] args)
{
ManagementEventWatcher watcher = new ManagementEventWatcher();
WqlEventQuery wqlQuery = new WqlEventQuery("SELECT * FROM Win32_DeviceChangeEvent");
watcher.EventArrived += new EventArrivedEventHandler(DeviceArrivedEventHandler);
watcher.Query = wqlQuery;
watcher.Start();
watcher.WaitForNextEvent();
Console.ReadKey();
}
static void DeviceArrivedEventHandler(object sender, EventArrivedEventArgs e)
{
string val = e.NewEvent.Properties["DriveName"].Value.ToString();
Console.WriteLine(val);
}
}
}
Wenn ich einen USB-Stick anstecke, dann reagiert dieser Code auf das Ereignis. Leider funktioniert dieser Code aber nicht beim Verbinden von Netzlaufwerken.
Laut dieser Seite sollte das aber funktionieren.
Was müsste ich ändern, damit der Code auf alle Arten von Laufwerken funktioniert?
Ich würde da jetzt ein HashSet verwenden.
In Zeile 35 könnte man dann abfragen, ob der Eintrag im HashSet schon vorhanden ist.
Wenn ja, dann mit dem nächsten Eintrag weitermachen.
Wenn nein, dann den Eintrag zum HashSet und zur ListView hinzufügen
Eine Offtopic-Frage von mir weil es mich einfach interessiert. Hast Du den Controllino mit der Arduino-IDE programmiert oder vielleicht sogar mit Atmel Studio?
Über den Installer habe ich es die letzten drei Tage immer wieder mal probiert. Aber mehr als die 1.2er Version der Tools wurde mir nicht angezeigt.
Habe jetzt noch einen Link gefunden, der mir zu helfen scheint. Bin grad am Installieren.
Vielen Dank für die Info! Ich dachte immer, VS zeigt auch aktuelle Patches im Benachrichtigungsfenster an.
Die von Dir verlinkten Patches habe ich jetzt installiert.
Meine Version von Visual Studio ist nun 14.0.25431.01 Update 3
Die Version der Visual Studio Tools für universelle Windows-Apps hat sich leider nicht geändert. Die Version ist nach wie vor die 14.0.24720.00. Mit welchem Paket kann ich diese updaten?
Hallo,
anfang der Woche habe ich einen Raspberry Pi3 bekommen, auf dem ich Windows 10 IoT installiert habe.
Visual Studio 2015 Update 3 habe ich installiert. Ebenso die IoT Projekt templates. Mit dem Projekttemplate habe ich ein Projekt ohne eigenen Code erzeugt. Dieses wollte ich testen.
Leider funktioniert das überhaupt nicht. Das Projekt kann nicht bereit gestellt werden. Ich erhalte immer folgende Fehlermeldung:> Fehlermeldung:
Die Verbindung mit dem Microsoft Visual Studio Remote Debugger mit dem Namen "Pi3" konnte nicht hergestellt werden. Visual Studio Remote Debugger (MSVSMON.EXE) wird auf dem Remotecomputer anscheinend nicht ausgeführt.
Wenn ich auf dem RaspberryPi über das Dashboard den Button für den Start des Remote debuggers drücke, erhalte ich folgende Fehlermeldung:> Fehlermeldung:
Failed to start the Visual Studio Remote Debugger. Make sure the remote debugger is copied to the device using Visual Studio
For more information please visit
>
Die Einstellungen entsprechen denen, wie in der Fehlermeldungen angegebenen Link.
Über Google habe ich aber nun folgendes festgestellt:
- Wenn ich über die Systemsteuerung die Änderung für VS2015 anwähle, dann erscheinen bei mir nur die Tools 1.2. Meines Wissens gibt es aber bereits 1.4
- In dem Link Punkt 4 steht, dass 14.0.25208.00 die erforderliche Version der Visual Studio Tools for Universal Windows Apps sind. Ich habe jedoch nur eine niedrigere Version - siehe Bild. Wie bekomme ich die Tools aktualisiert? Es wird mir kein Update angeboten.
Zusammenfassend gefragt. Wie bekomme ich eine App auf den RaspberryPi 3?
Wie wäre es damit?
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
namespace Forum
{
class Program
{
static void Main(string[] args)
{
Regex NUMBERFILES = new Regex(@".+?(\d+)\s*files.+$");
List<string> lastLines = new List<string>();
lastLines.Add(" 130869837 954273 895 files, 2167 folders");
lastLines.Add(" 130869837 954273 1895 files, 2167 folders");
lastLines.Add(" 130869837 954273 4895 files, 2167 folders");
lastLines.Add(" 130869837 954273 10895 files, 2167 folders");
lastLines.Add(" 130869837 954273 298525 files, 2167 folders");
foreach (string lastLine in lastLines)
{
Match match = NUMBERFILES.Match(lastLine);
if ((match != null) && match.Success)
{
string output = lastLine + " =====> " + match.Groups[1].ToString();
Console.WriteLine(output);
}
else
{
Console.WriteLine("Fehler!");
}
}
Console.ReadKey();
}
}
}
Ja, ich bin mit dem Debugger schon X-mal die Methode durchgegangen.
Ist die besagte Spalte angewählt, dann ist nach
shotList.Add(shot);
die Liste weiterhin leer.
Ist die Spalte nicht angewählt oder eine andere Spalte angewählt, dann ist der Eintrag in der Liste vorhanden.
Wo kann ich sonst noch guggen?
Hier Teil 2.
In DataGrid.z01 umbenennen.
Also ich greife meiner Meinung nach nicht in die Aktualisierung des Grids ein.
Ich habe folgende Klassen
public class ResultCollection : ObservableCollection<Result>
public class Result
{
#region Fields
private List<Shot> shots;
#endregion
#region Properties
public Shooter Shooter { get; set; }
public Team Team { get; set; }
public List<Shot> Shots
{
get
{
shots = shots.OrderBy(v => v.Value).ToList();
return shots;
}
set
{
shots = value;
}
}
#endregion
#region Constructor
public Result(Shooter shooter, Team team, List<Shot> shotList)
{
Shooter = shooter;
Team = team;
Shots = shotList;
}
#endregion
}
Befüllt wird immer mit der Methode.
private void ProcessDatabaseResults()
{
Results.Clear();
HashSet<int> ids = new HashSet<int>();
Shooter shooter = null;
Team team = null;
List<Shot> shotList = null;
foreach (DataRow row in dbResults.Rows)
{
Shot shot = DataColumnConverter.ShotdataToShot(row["shotdata"]);
if (shot == null)
{
continue;
}
int startNumber = DataColumnConverter.IdToInteger(row["idShooters"]);
if(!ids.Contains(startNumber))
{
ids.Add(startNumber);
shooter = DataColumnConverter.ColumnsToShooter(row);
shooter.Id = startNumber;
shooter.IsDisqualified = false;
team = DataColumnConverter.ColumnsToTeam(row["clubsname"]);
team.Members++;
shotList = new List<Shot>();
Results.Add(new Result(shooter, team, shotList));
}
shotList.Add(shot);
}
}
Wenn die besagte Spalte für die Auf-Absteigende Sortierung angewählt ist, dann ist Result.Shots leer.
Ich kapier nicht, warum.
Zur Veranschaulichung habe ich ein kleines Video beigefügt. Teil 2 folgt separat.