Forenbeiträge von schaedld Ingesamt 1.433 Beiträge
denn besonders für einen Programmierer ist es sehr untypisch, dass man sich vor acht Uhr blicken lässt. Ist aber auch nur ein Klischee (Ich fange immer um 06.00 Uhr an und gehe dann gegen 17.00 Uhr nachhause).
Mein komischstes Erlebnis war:
Zu Besuch bei einem Ex-Kumpel von mir zu Tekken II Gamesession. Natürlich haben wir auch gegessen und Eistee geschlürft. Was ich nicht wusste ist dass unser Gastgeber mir ein LSD in den Eistee getan hat, sodass ich mein Unwohlsein auf einen gegessene Pizza am Vorabend zurück führte. Komisch fand ich dann auch, dass sich plötzlich der Teppichboden zu bewegen schien...
Mittlerweile haben sich unsere Wege getrennt... 8)
Wenn Du Daten von Form2 auf Form1 übertragen willst, dann musst Du beim Abfüllen der Textbox in Form2 ein Event erstellen, dass gefeuert wird, wenn zum Beispiel der schliessen Button geklickt wird. In Form1 musst Du dann das Ereignis aus Form2 abonnieren.
Kleines Beispiel:
Form1:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace WindowsApplication2 {
public partial class Form1 : Form {
Form2 frm2 = null;
public Form1() {
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e) {
}
private void button1_Click(object sender, EventArgs e) {
frm2 = new Form2();
frm2.Show();
// Abonnieren des Ereignisses von Form2
frm2.OnTextChanging += new Form2.TextChangeHandler(frm2_OnTextChanging);
}
void frm2_OnTextChanging(object sender, Form2.TextChangeEventArgs e) {
listBox1.Items.Add(e.Wert);
}
}
}
Form2 sieht dann so aus:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace WindowsApplication2 {
public partial class Form2 : Form {
#region Eventklassen Definition
/// <summary>
/// Öffentliche Klasse für die Events
/// </summary>
public class TextChangeEventArgs : EventArgs
{
/// <summary>
/// Private Variable für den Wert der übernommen werden soll.
/// </summary>
private string _wert;
/// <summary>
/// Eigenschaft über welche dann der Wert gesetzt, ausgelesen werden kann.
/// </summary>
public string Wert {
get { return _wert; }
}
/// <summary>
/// Konstruktor der beim Erstellen des Ereignisses verwendet wird und dem
/// dann der Text mitgegeben wird.
/// </summary>
/// <param name="wert">Textwert aus Form2</param>
public TextChangeEventArgs(string wert) {
this._wert = wert;
}
}
#endregion
#region Delegate Definition
/// <summary>
/// Delegate Erstellung, damit das Event sein Wert übergeben kann.
/// </summary>
/// <param name="sender">Standard Object</param>
/// <param name="e">Meine Parameter die übergeben werden aus der Eventklasse</param>
public delegate void TextChangeHandler(object sender, TextChangeEventArgs e);
#endregion
#region Event Deklaration
/// <summary>
/// Ereigniserstellung, damit mit diesem gearbeitet werden kann.
/// </summary>
public event TextChangeHandler OnTextChanging;
#endregion
public Form2() {
InitializeComponent();
}
private void Form2_Load(object sender, EventArgs e) {
}
/// <summary>
/// Überprüfen ob das Ereignis bereits erstellt worden ist, wenn nein
/// wird eines erstellt.
/// </summary>
/// <param name="e"></param>
protected virtual void OnTextChangedEvent(TextChangeEventArgs e) {
if (OnTextChanging != null) {
OnTextChanging(this, e);
}
}
/// <summary>
/// Text abfeuern mit dem OnTextChanging Event.
/// </summary>
/// <param name="sender">Standardwert für Button1</param>
/// <param name="e">Standardwert für Button1</param>
private void button1_Click(object sender, EventArgs e) {
OnTextChangedEvent(new TextChangeEventArgs(textBox1.Text));
this.Close();
}
}
}
Solltes Du mit Delegaten oder Ereignissen noch nicht ganz klar sehen, dann empfehle ich Dir 📗 (nicht böse gemeint).
Da passiert auch was nur, wenn der Index der Listbox geändert hat. Hierzu würde ich sonst das Click Ereignis verwenden, dann kannst Du sicher gehen, dass die Aktion auch ausgeführt wird.
CheckBox_Ja.Checked = true
Das ist eine Zuweisung, schreit da nicht der Compiler
Wo Du recht hast, hast Du recht (war ein bisschen schluderig meinerseits, sorry )
Wie wärs damit? (ungetestet)
protected void Wizard1_FinishButtonClick(object sender, WizardNavigationEventArgs e)
{
string mailBodyAllData = string.Empty;
string mailBodyNoData = string.Empty;
MailMessage mail = new MailMessage();
mail.From = new MailAddress("**");
mail.To.Add("**");
mail.Subject = "Testmail";
mail.IsBodyHtml = true;
switch(CheckBox_Ja.Checked == true){
case false:
mailBodyAllData = TextBox_Anforderung_Vorname.Text +
TextBox_Anforderung_Vorname.Text +
TextBox_Anforderung_Vorname.Text +
TextBox_Benutzer_Gebaude.Text +
TextBox_Benutzer_Gebaude.Text;
break;
default:
mailBodyNoData = TextBox_Anforderung_Vorname.Text + "Keine Daten";
break;
}
SmtpClient smtp = new SmtpClient("**");
smtp.Send(mail);
}
Eigentlich ist es ja ganz einfach auf eine Oracle-DB zuzugreifen. Man muss den Namespace System.Data.OracleClient sowohl in der using Direktive verwenden wie auch als Verweis ins Projekt reinziehen.
string connections = "DATA SOURCE=%Datenbankname%; User ID=%UserID%; Password=%Password%; Integrated Security=YES /NO"
string commando = "Select * from irgendwelcher Tabelle;"
OracleConnection connOra = new OracleConnection(connections);
OracleCommand cmd = new OracleCommand(commando, connOra);
// Wenn Du Eingabefelder hast, dann musst Du das OracleCommand mit Parametern abfüllen, solltest es in den Links finden.
try{
connOra.Open();
cmd.ExecuteOracleScalar();
connOra.Close();
}catch(Exception)
{
}
Ansonsten kann ich Dir folgenden Artikel noch empfehlen.
Hallo zusammen
Ich finde es erstaunlich wieviele doch schon in Projekte WPF nutzen dürfen /können /müssen. Wir haben momentan den Einsatz von ASP.NET 2.0 in Verbindung mit der WebClientFactroy und dem Worfklow, aber leider noch kein WPF 😉
Zum einen bin ich froh noch nicht allzu viel damit zu tun zu haben, da ich nicht wirklich der Superdesigner bin und zum anderen ist dass dann ja wieder eine ganz andere Baustelle des .NET.
Mal sehen was die Zukunft bringt. 🤔
Get-WmiObject Win32_VideoController
Auflistung der möglichen Modi auf den Video Controllern.
Get-WmiObject Win32_DisplayControllerConfiguration
eine andere Art der Auflistung.
Wenn Du nach einer Klasse in der WMI suchst, dann kannst Du mit folgendem Query eine kleien Hitliste für Dich erstellen, welche Klasse für Dein Vorhaben verwendet werden sollte:
Get-WmiObject -query "Select * from meta_class" | Select-String -pattern Video
SqlConnection connection = null;
Die connection ist mit NULL initialisiert. Meiner Meinung kann es so nicht gehen.
string insertQuery = "CREATE TABLE TEST (KURS CHAR(20) NOT NULL, ID NUMBER NOT NULL)";
string connection = (@"Driver={SQL Native Client}; Data Source=.\SQLEXPRESS; AttachedDBFilename=C:\Dokumente und Einstellungen\belfry\Eigene Dateien\Schuleba.mdf; Initial Catalog=Schuleba;");
SqlConnection conn = new SqlConnection();
SqlCommand cmd = new SqlCommand();
conn.ConnectionString = connection;
cmd.Connection = conn;
cmd.CommandString = "CREATE TABLE TEST (KURS CHAR(20) NOT NULL, ID NUMBER NOT NULL)";
try{
conn.Open();
cmd.ExeCuteNonQuery(),
conn.close}
catch(Execption){
Console.WriteLine(ex.ToString);
}
Code ist ungetestet, daher noch ein bisschen übeben. Vielleicht hilft Dir dieser Artikel noch ein bisschen weiter.
PowerShell ist eine gute Quelle sich in der Materie zurecht zu finden (macht ziemlich viel Spass 😉 )
PowerShell installieren und los kanns gehen. Da diese Shell-Sprache das .NET verwendet, kannst Du auch die gleichen Klassen, wie mit der C# Programmierung verwenden. Die Syntax ist ein bisschen anders, aber wenn mans in den Griff kriegt, dann bringt man sehr funktionale Scripts fertig 🙂
Also schon der erste Link meiner geposteten Suchergebnisse sieht vielversprechend aus (man muss sich halt Zeit nehmen sich einzulesen und den Spreu vom Weizen zu trennen 😉 )
Also bei mir gibt er zwei Attribute raus, die mit der Bildschirmauflösung so ziemlich übereinstimmen.
ScreenHeight : 900
ScreenWidth : 1440
Die Zeile
Get-WmiObject Win32_DesktopMonitor
liefert mir folgendes Ergebnis:
__GENUS : 2
__CLASS : Win32_DesktopMonitor
__SUPERCLASS : CIM_DesktopMonitor
__DYNASTY : CIM_ManagedSystemElement
__RELPATH : Win32_DesktopMonitor.DeviceID="DesktopMonitor1"
__PROPERTY_COUNT : 28
__DERIVATION : {CIM_DesktopMonitor, CIM_Display, CIM_UserDevice, CIM_LogicalDevice...
__SERVER : WS-56000
__NAMESPACE : root\cimv2
__PATH : \\WS-56000\root\cimv2:Win32_DesktopMonitor.DeviceID="DesktopMonitor1"
Availability : 3
Bandwidth :
Caption : Default Monitor
ConfigManagerErrorCode :
ConfigManagerUserConfig :
CreationClassName : Win32_DesktopMonitor
Description : Default Monitor
DeviceID : DesktopMonitor1
DisplayType :
ErrorCleared :
ErrorDescription :
InstallDate :
IsLocked :
LastErrorCode :
MonitorManufacturer :
MonitorType : Default Monitor
Name : Default Monitor
PixelsPerXLogicalInch : 96
PixelsPerYLogicalInch : 96
PNPDeviceID :
PowerManagementCapabilities :
PowerManagementSupported :
ScreenHeight : 900
ScreenWidth : 1440
Status : OK
StatusInfo :
SystemCreationClassName : Win32_ComputerSystem
SystemName : WS-56000
__GENUS : 2
__CLASS : Win32_DesktopMonitor
__SUPERCLASS : CIM_DesktopMonitor
__DYNASTY : CIM_ManagedSystemElement
__RELPATH : Win32_DesktopMonitor.DeviceID="DesktopMonitor2"
__PROPERTY_COUNT : 28
__DERIVATION : {CIM_DesktopMonitor, CIM_Display, CIM_UserDevice, CIM_LogicalDevice...
__SERVER : WS-56000
__NAMESPACE : root\cimv2
__PATH : \\WS-56000\root\cimv2:Win32_DesktopMonitor.DeviceID="DesktopMonitor2"
Availability : 8
Bandwidth :
Caption : Plug and Play Monitor
ConfigManagerErrorCode : 0
ConfigManagerUserConfig : False
CreationClassName : Win32_DesktopMonitor
Description : Plug and Play Monitor
DeviceID : DesktopMonitor2
DisplayType :
ErrorCleared :
ErrorDescription :
InstallDate :
IsLocked :
LastErrorCode :
MonitorManufacturer : (Standard monitor types)
MonitorType : Plug and Play Monitor
Name : Plug and Play Monitor
PixelsPerXLogicalInch :
PixelsPerYLogicalInch :
PNPDeviceID : DISPLAY\PHL0862\4&3B7ACE4F&0&80861500&00&02
PowerManagementCapabilities :
PowerManagementSupported :
ScreenHeight :
ScreenWidth :
Status : OK
StatusInfo :
SystemCreationClassName : Win32_ComputerSystem
SystemName : WS-56000
ScreenWidth und ScreenHight sind die gesuchten Attribute...
WMI Klasse: Win32_DesktopMonitor
PowerShell Script
Get-WmiObject Win32_DesktopMonitor
Dann erhälst Du die gesuchten Angaben.
Übers Netzwerk mit der Powershell (wenn alles korrekt funktioniert).
Get-WmiObject Win32_DesktopMonitor -computername %DeinPC%
hab ich jetzt den Download Link nicht gesehen oder hast Du diesen vergessen? 🤔
EDIT: Yust in dem Moment als ich die Antwort schrieb, hast Du die Datei hochgeladen. Ja man kann nur eine Datei gleichzeitig hochladen.
using System;
using System.Collections.Generic;
using System.Text;
namespace ConsoleApplication1 {
class Program {
static void Main(string[] args) {
if (args != null) {
foreach (string str in args) {
Console.WriteLine("Du hast als Startparameter eingegeben {0} ", str);
}
}
}
}
}
Ich verweise mal auf: :rtfm: 📗 🛈 , da ich den Eindruck habe, dass Dir grundlegensten Sachen betreffend C# fehlen (nicht böse nehmen, wir haben alle mal angefangen 😉 )
Und hier der klassische Einzeiler der PowerShell für das Auslesen von CPU-Daten:
get-wmiobject Win32_Processor
Und dass ist das Resultat:
__GENUS : 2
__CLASS : Win32_Processor
__SUPERCLASS : CIM_Processor
__DYNASTY : CIM_ManagedSystemElement
__RELPATH : Win32_Processor.DeviceID="CPU0"
__PROPERTY_COUNT : 44
__DERIVATION : {CIM_Processor, CIM_LogicalDevice, CIM_LogicalElement, CIM_ManagedSystemElement}
__SERVER : WS-56000
__NAMESPACE : root\cimv2
__PATH : \\WS-56000\root\cimv2:Win32_Processor.DeviceID="CPU0"
AddressWidth : 32
Architecture : 0
Availability : 3
Caption : x86 Family 15 Model 4 Stepping 3
ConfigManagerErrorCode :
ConfigManagerUserConfig :
CpuStatus : 1
CreationClassName : Win32_Processor
CurrentClockSpeed : 3192
CurrentVoltage : 12
DataWidth : 32
Description : x86 Family 15 Model 4 Stepping 3
DeviceID : CPU0
ErrorCleared :
ErrorDescription :
ExtClock : 800
Family : 2
InstallDate :
L2CacheSize : 0
L2CacheSpeed :
LastErrorCode :
Level : 15
LoadPercentage : 6
Manufacturer : GenuineIntel
MaxClockSpeed : 3192
Name : Intel(R) Pentium(R) 4 CPU 3.20GHz
OtherFamilyDescription :
PNPDeviceID :
PowerManagementCapabilities :
PowerManagementSupported : False
ProcessorId : BFEBFBFF00000F43
ProcessorType : 3
Revision : 1027
Role : CPU
SocketDesignation : XU1 PROCESSOR
Status : OK
StatusInfo : 3
Stepping : 3
SystemCreationClassName : Win32_ComputerSystem
SystemName : WS-56000
UniqueId :
UpgradeMethod : 1
Version : Model 4, Stepping 3
VoltageCaps :
Wieso entfremdest Du nicht die Resx-Datei? Dort kannst Du ja Deine Select Befehle speichern und brauchst sie dann nur dort zu ändern, wenn eine Änderung fällig ist. Am Quellcode ist dann immer noch alles beim Alten (wenn Du nichts hinzufügst oder entfernst..).
Als kleines Beispiel:
Form1.cs
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Timer_Appl.Classes;
namespace Timer_Appl
{
public partial class Form1 : Form
{
TimerIncrement TimerInk = new TimerIncrement();
public Form1()
{
InitializeComponent();
}
/// <summary>
/// Butten Aktion die die Methode in der TimerIncrement ausführt.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Event_StartTimer(object sender, EventArgs e)
{
TimerInk.Startwert = Convert.ToInt32(textBox1.Text);
TimerInk.Zaehler = Convert.ToInt32(textBox2.Text);
textBox3.Text = Convert.ToString(TimerInk.StartMyTimer());
}
}
}
TimerIncrement.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Timer_Appl.Classes
{
class TimerIncrement
{
/// <summary>
/// Klassenfelder Initialisierung.
/// </summary>
private int _startwert;
private int _zaehler;
/// <summary>
/// Setzen der Eigenschaften für den StartWert und den Zähler.
/// </summary>
public int Startwert
{
get { return _startwert; }
set { _startwert = value; }
}
public int Zaehler {
get { return _zaehler; }
set { _zaehler = value; }
}
/// <summary>
/// Methode für die Ausführung.
/// </summary>
/// <returns></returns>
public int StartMyTimer()
{
Startwert += Zaehler;
return Startwert;
}
}
}
Und das Projekt als Zip (Visual Studio 2008 Express).
Dass könnte am RowState liegen, da bei jeder Operation dieser geschrieben wird.
(Added, Deleted, Detached)
Überprüfe doch vor dem Laden oder vor der Darstellung der Daten, die RowStates und bearbeite sie dann entsprechend.
string ant; ant = antwort.Text; // hier wird die Exception ausgelöst string[] array2 = { "Antwort 1", "Antwort 2", "Antwort 3", "Antwort 4", "Antwort 5" };
String antw wird gar kein Wert zugewiesen, darum erhälst Du die NullReferenceException. Dei Variable muss zuerst initialisiert werden bevor man sie gebrauchen kann. Wenn es nicht allzu früh am Morgen ist, dann könntest Du dass versuchen und es sollte klappen.
string ant = antwort.Text; // <-- Direkte Zuweisung des Textboxwertes zu Deinem String.
string[] array2 = { "Antwort 1", "Antwort 2", "Antwort 3", "Antwort 4", "Antwort 5" };
Ansonsten wirds Zeit nochmals einen Kaffee rein zu schütten 😭
Hallo
Versuche doch mal im Appwiz.cpl die Installation zu reparieren. Wenn dass nichts helfen sollte, dann sichern der Daten und Deinstallation, Reboot und Neuinstallation des SQL Server 2008.
Nichts zum Inhalt, aber das "Do" in den Methodennamen würde ich weglassen, ist falsches Englisch und im Deutschen würdest du doch auch nicht TuÖffneDatenbank schreiben, oder? Nicht wirklich, war ja auch nur auf die Schnelle 😉
Versuchs mal mit einer anderen DB (Sql Express oder ähnlichem). Wenn dies dann weiterhin auftritt, dann könnte ein "Reparieren" von Visual Studio mit dem Installationsmedium eventuell helfen.
Entsprechenden Namespace nicht referenziert? (OleDBConnection)
Geräte allgemein unter Windows kann man mit WMI abfragen. Wenn Du den Typ weisst kannst Du dies auch gleich in der Abfrage mitgeben.
Anbei der WMI Code Generator von Microsoft, der Dich dabei unterstützen kann.
<entfernt>
Ich würde rückfragen ob der Link in der About-Box Deines Programms reicht, damit Du die Lizenzvereinbarungen einhälst. Ansonsten sieht dass doch schon korrekt aus.
Das liegt daran, dass beim ersten Mal der gesamte Source-Code kompiliert wird. Ansonten versucht mal den temporären .NET Ordner zu löschen, dann sind auch nur die notwendigen Dateien, die Deine Lösung braucht drinnen es es geht eventuell schneller.
Die Codebehind Datei implementiert die Logik, während die ASPX Seite eigentlich zu Darstellungszwecken dient.
verwendetes Datenbanksystem: SQL Server 2005
Hallo zusammen
Nachdem ich mich ein bisschen über LINQ schlau gemacht habe, ist mir aufgefallen, dass es ja auch möglich ist, dass INSERT, UPDATE und DELETE Commands über eine LINQDataSource durchgeführt werden können.
Ich bin mir nicht ganz sicher, aber könnte dies das Ende der TableAdapters und DataSets bedeuten? Oder liege ich hier komplett falsch?
Danke für eure Rückmeldungen.
Vielleicht helfen Dir diese Tipps /Beispiele mit LINQ weiter.
Du könntest ein Interface erstellen, welches dann an Deine Klasse gebunden ist, dann müsstest Du nur in der jeweiligen Klasse die Datenbank spezifischen Commands und Connections referenzieren.
Dein Interface könnte zum Beispiel so aussehen:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace DATA_ACCESS
{
interface IDBOperations
{
void DoOpenDataBase();
void DoQueryDataBase();
void DoCloseDataBse();
}
}
Das wäre dann für die allgemeinen Operationen die Du mit einer DB machen kannst. Danach kannst Du dieses in eine Klasse Deiner Wahl, zum Beispiel DBSql, oder DBOracle oder ähnliches implementieren und dort die jeweiligen DB spezifischen Commands, Connections etc. festlegen.
Beispielklasse DATA welches das Interface implementiert
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
namespace DATA_ACCESS
{
class DataBase:IDBOperations
{
#region IDBOperations Member
void IDBOperations.DoOpenDataBase()
{
//Hier Dein Code
}
void IDBOperations.DoQueryDataBase()
{
//Hier Dein Code
}
void IDBOperations.DoCloseDataBse()
{
//Hier Dein Code
}
#endregion
}
}
Es gibt evenutell noch ausgeklügeltere Varianten, die eventuell von einem erfahreneren Developer als mit gepostet werden könnten. 😭
Vielleicht hilft Dir dieser Artikel weiter.
Weitere Suchergebnisse.
als db system verwende ich gerde access Ich bin mir ziemlich sicher, dass Access die Zahlen auch so nimmt wie SQL Express. Andersum gesagt, wenn Zahlen an eine DB, sei es nun Access, SQL Server oder Oracle, ich habe noch nie gesehen, dass ein Zahlentyp als '1' eingegeben wird. Da werden die Zahlen immer so übergeben:
Nur so zu Anmerkung: Wenn die Werte übergeben werden dann sieht dass SQL mässig so aus:
INSERT INTO [Entries] ([CategoryFk], [EintragsText]) VALUES (@p1, @p2)
Schau Dir doch mal folgenden Link an: C# und ....
Auszug aus der Seite:
- Daten hinzufügen
Da wir nun eine der Möglichkeiten gesehen haben wie Daten abgefragt werden können, werden wir nun einen Datensatz hinzufügen. Dies passiert wie folgt:
SqlCommand com = new SqlCommand("INSERT INTO tPerson (Firstname, Lastname) VALUES (@firstname, @lastname)", conn);
com.Parameters.Add(new SqlParameter("@firstname", "fritz"));
com.Parameters.Add(new SqlParameter("@lastname", "huber"));
com.ExecuteNonQuery();Wieder erstellen wir einen SqlCommand, der ein SQL Statement übergeben bekommt sowie die Datenbankverbindung. Hier passiert dann noch etwas spezielles. Aus Sicherheitsgründen werden die Daten nicht direkt ins SQL Statement geschrieben, sondern via SqlParameter. Dieser Schritt hat einige Vorteile was das Thema SQL Injection etc. betrifft. Sollte also immer in dieser Form angewandt werden. Mittels der ExecuteNonQuery-Methode des SqlCommand-Objektes wird der Befehl auf der Datenbank ausgeführt und der Datensatz eingefügt.
Sharp Develop it's free... Aber ich bin mir nicht sicher ob's auch schnell ist...
Bei mir ist Visual Studio 2008 Ex aber schnell (Schnelligkeit ist ja immer ein rein subjektiver Ansichtspunkt 😭 )
Ich frage mich natürlich jetzt was für ein Datum gesetzt wird. Entweder bin ich schon zu lange vor dem Schirm oder ich sehe kein setzen des Datums in der Stored Procedure. Oder übergibst du es als DateTimeObject von C# aus?
Wenn Du ein Update machst dann machst Du dass normalerweise mit einem eindeutigen Identifier (Primary Key) der den zu aktualisierenden Datensatz kennzeichnet. Wenn Du diesen nicht übergibts, ihn aber erwartest, dann wirf er diese Exception.
VS 2008 WPF Designer Improvements Diese Improvements sind meienr Meinung eigentlich schon in einem Produkt dass ausgeliefert werden sollte drin zu sein. Denn der Designer in Visual Studio 2008 ist eine Frechheit 😭
Sollte doch gehen. Ansonsten schau mal auf der Eigenschaftenseite der app.config nach. Dort kannst Du angeben ob diese eine embedded Resource ist oder nicht (soweit ich dass jetzt auswendig weiss). Dann sollte es auch mit dem kompilieren klappen.
Was jetzt Checkbox oder Textbox? Wenn Die Checkbox das Problem ist dann führt er die Undo-Funktion wahrscheinlich beim Post_Back aus (sollte er eigentlich auch beim Deselektieren).
Auf Änderungen eines Control Zustands kann man die Ereignisse der einzelnen Controls mit Code füllen, dann macht es genau dass wenn es soll und wann es darft.
Ich denke da gibt es sicherlich AGB, ansonsten frag doch mal Google offiziell an.
Hallo zusammen
Da ich letzte Woche einen UML 2.0 Kurs mit Frank Eller besuchen durfte, konnte ich mich auch mal ein bisschen mit dem Entwurf einer Software, im Detail beschäftigen. Damit ich nicht "nur" coden muss /darf /kann, habe ich mir zum Ziel gesetzt ein Programm zu erstellen, dass folgendes kann:
ZIEL: Eine Erstellung eines Trainingsplans für einen Kraftsportler, der dann die verschiedenen Varianten und Kraftarten auswählen kann.
Zu verwendenden Technologien: .NET 3.0 /.NET 3.5 WPF
Wenn ich mit dem Projekt fertig werde, dann soll /kann es aufgrund seiner Einfachheit eventuell als kleiner "Einsteigerleitfaden" dienen, der mit eurer Hilfe entstehen kann /darf /soll.
Nun habe ich mal für mich ein Use Case, ein Aktivitätsdiagramm und ein spährliches Klassendiagramm erstellt und wäre für Anregungen und Kritiken sehr dankbar.
Falls die Grafiken nicht leserlich sein sollten habe ich diese noch als ZIP angehängt.
Gar nicht. Mit WPF/XAML/Silverlight und Co. hat MS die Werkzeuge erfunden, um uns Entwickler durch Leute zu ersetzen, die diesen Job besser beherrschen. Traurig aber wahr... Und genau in dieser Hinsicht entwickelt sich das Rapid Application Development. Die Leute dort einsetzen, wo sie am meisten Leistung einbringen.
Oder doch Expression Blend. Dort hast Du keine Umschalterei 🙂
Wenn Du einen W2003 computer gehäbt hättes dann hättest Du auch mit dsget oder dsquery Deine Avgrage durchführen können.
Get-WmiObject Win32_ComputerSystem
liefert dier ein paar Informationen zurück. Wenn du mehr haben willst dann kannst du dies wie folgt in Erfahrung bringen.
Get-WmiObject Win32_ComputerSystem | Get-Member -Membertype Property
Eine Zeile et voilà c'est fait...