Eleu

Die Gruppenrichtlinien, die für den Computer gelten, werden weiterhin angewendet, da der Computer ja weiterhin Mitglied der Domäne ist. Die Gruppenrichtlinien, die für Domänen-Benutzer gelten, werden nicht angewendet, da sich kein Domänen-Benutzer angemeldet hat.

Du hast dann dein Handy mit seiner SIM und zusätzlich die App, welche wenn sie mit deiner FritzBox verbunden ist auf deine Festnetznummer der Telekom reagiert. Ich habe an meiner FritzBox aktuell 2 DECT-Telefone und 4 Smartphones mit FritzFonApp aktiv.
Anrufbeantworter ist eine Funktionalität der FritzBox. Je nach Einstellungen kannst du dir dann die Nachricht an einem angeschlossenen Telefon-Endgerät anhören bzw. per E-Mail zuschicken lassen und dir die angehängte .wav-Datei anhören.

Ich hatte in einer Außenstelle mal was ähnliches, da hatte ein Kollege an dem "core" (so nenn ich das jetzt einfach mal) auf allen ports (cisco) Spanning-tree portfast konfiguriert. Da war das problem das gleiche.
 
http://www.nwlab.net/know-how/Cisco/bpdu-guard.html

Im Normalfall gewinnt die GPO, die am nächsten am Objekt liegt, also wenn sich die spezielle GPO und die Default Domain Policy widersprechen gewinnt die GPO die direkt auf der OU liegt.
Du kannst auch im GPO-Editor schauen, ganz unten gibt es den Punkt "Gruppenrichtlinienergebnisse", da kannst du schauen welche Einstellungen von welchen Richtlinien übernommen werden wenn User X und Rechner Y "zusammenkommen".
€dit: Wenn eine Richtlinie auf der OU erzwungen wird, sticht diese allerdings afaik immer, egal was drunter ggf noch kommt.

Kleiner Kommentar:
1. Windows enthält seit ewig (2000?) einen eigenen FTP Client, wie man den scriptet hat man nach 10 Sekunden suchen, z.B. https://www.jscape.com/blog/using-windows-ftp-scripts-to-automate-file-transfers
2. Heute und seit etlichen Jahren sollte man unverschlüsseltes FTP vermeiden und statt dessen SFTP verwenden - auch hier gibt's kostenlose Skriptingmöglichkeiten, z.B. mit WinSCP: https://www.itworld.com/article/2928599/how-to-automate-sftp-file-transfers-in-microsoft-windows.html
 

Was passiert, wenn du den Task mit Systemrechten unabhängig von der Benutzeranmeldung ausführen lässt? Klappt das dann auch nicht?
 

Dann schau doch mal beim Treiber für deine Netzwerkkarte, ob du da beim Hersteller einen Treiber mit erweiterten Funktionen bekommst, oder ob es da noch eine Zusatzsoftware (Administrative Tools oder etwas in der Art) für gibt, bzw. ob du diese bereits installiert hast.
 
Schau mal hier.

diverse ICMP Angriffe: http://www.nm.ifi.lmu.de/pub/Fopras/fack00/HTML-Version/node53.html und andere

Ja stimmt, hatte ich nicht gesehen. Da geht es dann nur über diese Remotewebzugriffs-Funktionen.
Damit lassen sich dann nur Zugriffe auf freigegebene Ordner auf dem Server realisieren, wenn ich es richtig verstehe.

Hallo,
aber wenn man sich Windows Server 2016 Essential zulegt, braucht man doch gar keine CAL`s?
https://www.thomas-krenn.com/de/wiki/Windows_Server_2016_Editionsunterschiede
Die Variante mit 2 VM`s, davon eine als DC, geht dann allerdings nicht mit Essential.
Vielleicht verstehe ich es auch falsch? 
Eine Frage zu den VM`s auf dem Server. Ich vermute mal die erstellt man dann mit Hyper V?
Laufen diese beiden VM`s dann auf dem Hostsystem in der Windows Server 2016 Umgebung, wie beim VMWare Worstation Player, oder ist es wie beim VMWare ESXI? (Kein BS auf dem Hostsystem, VM`s auf dem Hostsystem nur über RDP erreichbar)  
Gruß
Eleu
 

Ich würds einfach mal ausprobieren. Wenn es dir erstmal reicht, ist es doch ok. Ansonsten Umtauschen und was anderes  (teureres) probieren.

Nur als kleinen Hinweis noch, weil's mich beim ersten Mal etwas Zeit gekostet hat, um es rauszufinden: Das zitierte hier ist die Stelle, ab der der Watcher aktiv ist. Durch das reine Erzeugen etc. passiert erstmal gar nichts. Erst, wenn man das hier setzt, bekommt man die Events auch in der Anwendung.

Aus diesem Grund finde ich es nicht gerade sinnvoll, dass Anfänger gleich mit einer grafischen Oberfläche anfangen, denn das Wissen ist einfach nicht vorhanden, wie Events eigentlich funktionieren.
Eine grafische Oberfläche läuft in einer Endlosschleife. In der Schleife werden jedes Mal die Eingabe entgegengenommen, verarbeitet und die Oberfläche neu gezeichnet. Ein Mausklick löst also im Grunde nicht das Event aus, sondern die Schleife befindet sich wieder an dem Punkt, wo sie die Eingabe überprüft wird und merkt, dass die Maustaste gedrückt wird. Schaut dann nach, ob ein Event implementiert wurde und wenn ja, dann wird die Implementierung aufgerufen. 
So ist es nun auch beim FileSystemWatcher. Es läuft eine Endlosschleife, die sich ein Stream mit Dateiänderungen anschaut und bei jedem Durchlauf wird geschaut, ob die letzte Dateiänderung mit deinen Filterkriterien, etc. übereinstimmt und dann schaut, ob das jeweilige Event implementiert wurde.
Den FileSystemWatcher kannst du auch in einer Form verwenden. Beispiel:
public Form1() { InitializeComponent(); FileSystemWatcher watcher = new FileSystemWatcher(@"D:\Test"); watcher.Changed += (sender, e) => textBox1.Text = $"Changed: {e.Name}"; watcher.Created += (sender, e) => textBox1.Text = $"Created: {e.Name}"; watcher.Deleted += (sender, e) => textBox1.Text = $"Deleted: {e.Name}"; watcher.Renamed += (sender, e) => textBox1.Text = $"Renamed: {e.OldName} => {e.Name}"; watcher.SynchronizingObject = this; watcher.EnableRaisingEvents = true; } Hierbei muss man aber wissen, dass die Endlosschleife in einem anderen Thread läuft als die Endlosschleife der grafischen Oberfläche und Änderungen an der UI darf nur der Thread der UI machen. Der FileSystemWatcher besitzt deswegen die Eigenschaft SynchronizingObject. Hier kann man das Objekt reinreichen, wer den FileSystemWatcher erzeugt hat und somit wird der Code über den UI-Thread ausgeführt.
Der FileSystemWatcher steht sogar in der Toolbox zur Verfügung und kann per Drag'n'Drop in die Form geschoben werden. Dabei wird der FilesystemWatcher folgendermaßen initialisiert:
// // fileSystemWatcher1 // this.fileSystemWatcher1.EnableRaisingEvents = true; this.fileSystemWatcher1.SynchronizingObject = this; this.fileSystemWatcher1.Changed += new System.IO.FileSystemEventHandler(this.fileSystemWatcher1_Changed); this.fileSystemWatcher1.Created += new System.IO.FileSystemEventHandler(this.fileSystemWatcher1_Created); this.fileSystemWatcher1.Deleted += new System.IO.FileSystemEventHandler(this.fileSystemWatcher1_Deleted); this.fileSystemWatcher1.Renamed += new System.IO.RenamedEventHandler(this.fileSystemWatcher1_Renamed); Das, was ich im oberen Code gemacht habe, kann man sich auch generieren lassen.

Um mit vier Zahlen zu rechnen:
new Addition(new Addition(new Addition(1,2).Calculate(), 3).Calculate(), 4) Eigentlich ganz einfach
new Addition(1,2).Calculate() => liefert Ergebnis X.
Ergebnis X packst du wiederum als ersten Summanden in deine Addition Klasse.
Wenn man das ganze nicht einzeilig machen möchte würde das so aussehen:
var x = new Addition(1,2).Calculate(); var result = new Addition(x, 3).Calculate(); Und bei vier Zahlen:
var x = new Addition(1, 2).Calculate(); var y = new Addition(x, 3).Calculate(); var result = new Addition(y, 4).Calculate();  

Hallo arlegermie,
vielen dank ich probiere das mal aus.
Ich hoffe ich nerve nicht, denn ich hätte noch ein paar Fragen, bzgl. der prinzipiellen Vorgehensweise, bei der Klassenprogrammierung mit Vererbung.
Ich habe jetzt folgende Klassen und ein Interface programmiert:
{ public interface ICalculation { double Calculate(); } public abstract class BinaryCalculation : ICalculation { protected double _firstOperand; protected double _secondOperand; public BinaryCalculation(double a, double b) { _firstOperand = a; _secondOperand = b; } public abstract double Calculate(); } public class Addition : BinaryCalculation { public Addition(double a, double b) : base(a, b) { } public override double Calculate() => _firstOperand + _secondOperand; } public class Multiplikation : BinaryCalculation { public Multiplikation(double a, double b) : base(a, b) { } public override double Calculate() => _firstOperand * _secondOperand; } public class ResultWriter { private string _file; public ResultWriter(string path) { _file = path; // Dateipfad und Dateiname werden der Variablen _file übergeben } public void WriteResultToFile(ICalculation calculation) //Vereerbung über das Interface ICalculation { File.AppendAllText(_file, $"{calculation.GetType()} result: {calculation.Calculate()}{Environment.NewLine}"); } } } Nun möchte ich eine Klasse programmieren, die 3 Variable addieren soll. Wenn ich es nun richtig verstanden habe, müsste ich nun eine neue Klasse Addieren2 programmieren, mit einer Methode Calculate2, sowie ein weitere abstrakte Klasse BinaryCalculation2, um nicht gegen das  Single-Responsibility-Prinzip zu verstoßen. Soll ich dann im Interface ICalculation diese Methode Calculate2 einfügen, oder soll ich ein neues Interface ICalculation2 hinzufügen?  
Oder kann ich die Calculate auch für Addition2 verwenden?
Sahe dann so aus:
public abstract class BinaryCalculation2 : ICalculation { protected double _firstOperand; protected double _secondOperand; protectet double _thirdOperand; public BinaryCalculation2(double a, double b, double c) { _firstOperand = a; _secondOperand = b; _thirdOperand = c; } public abstract double Calculate(); } public class Addition2 : BinaryCalculation2 { public Addition(double a, double b, double c) : base(a, b, c) { } public override double Calculate() => _firstOperand + _secondOperand + _thirdOperand; } Ist das die richtige Vorgehensweise?
Edit: Letztgenannte Variante funktioniert jedenfalls.

Könntest ein Environment.NewLine hinten dranhängen Wenn du bei File bleiben möchtest:
File.AppendAllText(_file, $"{calculation.GetType()} result: {calculation.Calculate()}{Environment.NewLine}"); Dann wird am Ende der Zeile ein Zeilenumbruch eingefügt.

Kleiner Tipp, diese Version ist auch kostenlos zumindest für dich als Privatanwender:
https://www.visualstudio.com/de/vs/community/

Genau

Perfekt. Dann funktioniert es nun wie es soll.
Klassenprogrammierung_in_C_Sharp.Addition  => calculation.GetType() (Der Laufzeittyp der Objektinstanz.)
result: 9  => die 9 entspricht dem Rückgabewert von calculation.Calculate()

Es geht um das DRY-Prinzip (Don't Repeat yourself). Wenn du nicht nur die Addition implementieren willst, sondern auch noch weitere Rechenoperationen, dann brauchen sie ebenfalls left und right. Damit man beide Variablen nicht für jede Operation kopieren muss, habe ich sie in eine abstrakte Klasse ausgelagert und jede Operation erbt von dieser Klasse. So braucht man die beiden Variablen nur ein mal definieren.
Abstrakte Klassen sind nicht instanziierbar. Du kannst also kein
new BinaryCalculation() aufrufen. Das führt sofort zu ein Kompilierfehler. Abstrakte Klassen dienen für eine Basisimplementierung einer Funktionalität. Klassen, die dann von der abstrakten Klasse erben, implementieren dann die konkrete Fachlogik. Die Subtraction-Klasse wird dann einfach so aussehen:
Public Class Subtraction Inherits BinaryCalculation Public Sub New(left As Double, right As Double) MyBase.New(left, right) End Sub Public Overrides Function Calculate() As Double Return Me.left - Me.right End Function End Class left und right braucht man ja nicht noch mal definieren, weil sie eben schon in BinaryCalculation definiert worden sind.
 

Deine Prozedur ShowErgebnis() ist schon mal nicht richtig. Es muss eine Funktion sein, die eben zahl1 und zahl2 addiert und das Ergebnis zurückgibt.
Dann kannst du in der Prozedur Button3_Click() einfach das Ergebnis einer TextBox zuweisen.
Public Class Addiere Public Property Zahl1 As Integer Public Property Zahl2 As Integer Function Berechne() As Integer Return Zahl1 + Zahl2 End Function End Class Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click Dim add As New Addiere add.Zahl1 = 5 add.Zahl2 = 3 TextBox1.Text = add.Berechne() End Sub Deine Addieren-Klasse sollte nicht dafür zuständig sein, das Ergebnis in die Textbox zu schreiben. Sie sollte nur das Ergebnis zurückliefern und die Anzeige in der Textbox sollte die Klasse übernehmen, die es auch braucht. Ansonsten ist deine Addieren-Klasse abhängig von der TextBox und die Klassen sollten so unabhängig wie möglich sein.

Google ist dein Freund und Helfer^^
 
1. Start the machine.
2. Press F10 to enter BIOS.
3. Security-> System Security
4. Enable Virtualization Technology (VTx) and Virtualization Technology Directed I/O (VTd).
5. Save and restart the machine. Das scheint jedenfalls bei den Leuten geholfen zu haben   Ansonsten mal hier schauen https://support.hp.com/us-en/document/c02000720

Wenn nur an der Profibus-Karte liegt: Schon mal mit nem Profibus zu Ethernet Adapter versucht?

Windows 7 kennt im Gegensatz zu Windows XP (auch 64 Bit, was mehr dem Windows Server 2003 x64 ähnelt) unterschiedliche Firewall-Profile für private und öffentliche Netzwerke. Da die 172.16.26.14/24 eine private und die 100.110.100.14/24 eine öffentliche IP-Adresse ist, greifen unterschiedliche Firewall-Profile. Es kann sein, dass Du die Firewall nur im privaten Profil deaktiviert hast, im öffentlichen Profil aber nicht.
Des weiteren: wenn Du sowieso nicht in die weite Welt raus willst, brauchst Du kein Standard-Gateway. Ich weiß nicht, wie Windows XP 64 Bit arbeitet, aber evtl. hat das das Ziel 100.110.100.14 nicht als Ziel im lokalen Subnetz angesehen und die Pakete deswegen an das Standard-Gateway geschickt, was es wohl nicht gibt, zumindest wenn ich mir da den ARP-Cache mit "Typ: invalid" anschaue. Was gibt ein traceroute auf die 100.110.100.14 aus? Wenn das versucht, über die 100.110.100.15 zu gehen, ist es dementsprechend klar, dass das nicht funktioniert.

Der ESXi lässt sich über einen Browser administrieren (Der Windows vSphere Client ist seit 6.5 relativ tot - die krempeln seit Version 6 alles auf HTML5 um)
Der VMware Converter kann auch direkt auf dem XP Rechner ausgeführt werden, um die Kiste zu virtualisieren. Entweder schreibt man ein Image auf eine USB-Platte oder Netzwerkshare, etc.
Der Prozeß ist hier beschrieben: https://blogs.vmware.com/workstation/2010/06/bring-your-windows-xp-pc-over-to-your-windows-7-pc-for-free-in-a-few-simple-steps.html
Hth, Ripper