תחומים - פורום חרדי מקצועי

יהיה מעניין לעשות השוואה מהירה בין האפליקציה המקורית לשלהם למצוא את ההבדל.

פורסם במקור בפורום CODE613 ב21/02/2016 01:24 (+02:00)

נסה את זה:
http://www.javadecompilers.com/
עריכת APK און ליין.
אם יש לך זמן לעבור על כל הקוד...
אבל לתועלת הרבים זה יכול לעזור.
(אולי אפשר אפילו לעשות שיחסום אוטומטית תמונות פרופיל של נשים).

פורסם במקור בפורום CODE613 ב20/02/2016 23:51 (+02:00)

עריכת קבצי APK היא לא מסובכת. יש תוכנות שמחזירות לקוד מקור!!

פורסם במקור בפורום CODE613 ב20/02/2016 23:17 (+02:00)

לחלץ apk זה משימה פשוטה:
ישנם אפליקציות רבות שיוצרות apk (השאלה אם הם פועלים בנתיב).
צריך לחפש בפליי סטור.
יתר על כן, איך שאני זוכר, כל אפליקציה באנדרואיד, יש את הapk שלה. (לא זוכר את המיקום. בלנ בהמשך...)
אך ייתכן שלא האפילקציה שונה אלא תעבורת האינטרנט. ואז לא יעזור להעתיק את הapk.
(זכור לי שווצאפ פרסמו שהם חוסמים אפליקציות לא שלהם).
בהצלחה.

פורסם במקור בפורום CODE613 ב20/02/2016 19:34 (+02:00)

מה זה אומר?
ואיך עושים את זה?

פורסם במקור בפורום CODE613 ב18/02/2016 09:17 (+02:00)

למה לא לחלק את הפורום לעוד נושאים.
צריך לחשוב.
האם לפי שפות?
לפי נושאים?
רעיונות...?

פורסם במקור בפורום CODE613 ב18/02/2016 00:41 (+02:00)

למה replace לוקח הרבה זמן?
כמה קבצים נשלחים כל כמה זמן ובאיזה גודל?

פורסם במקור בפורום CODE613 ב17/02/2016 00:48 (+02:00)

אנא פרט יותר.
מה השאילתה?
מי מחזיר את השגיאה? access?
נסה להריץ את את השאילתה ישר בaccess. מה קורה?
אגב, למה לא מסד נתונים של sql server?
מסד נתונים של Access לא נקרא מסד נתונים "אמיתי". רק דמוי.

פורסם במקור בפורום CODE613 ב16/02/2016 14:15 (+02:00)

אכן יותר יפה ומעניין.
לא יודע אם יותר משוכלל. (לא נרשמתי).
אבל יש עוד מערכות פורומים חינמיות. צריך ושווה לבדוק.

פורסם במקור בפורום CODE613 ב17/02/2016 10:31 (+02:00)

חושבני שכדאי לפצל את הפורום לכמה חלקים (חוץ מ"כללי"....).
ואין מערכת פורומים יותר יפה\משוכללת\מעודכנת????
(לא מתעסק בזה....).

פורסם במקור בפורום CODE613 ב17/02/2016 00:45 (+02:00)

למיטב ידיעתי
בכדי להשתמש במרחב שמות חייבים לייבא את ה DLL הספיציפי
כמובן שיש כאלה שמיובאים בדיפולט בפתיחת פרויקט

כוונתי לחלק:
יש טכנולוגית DLL.
באופן כללי ההסבר: אם אנחנו רוצים לשתף פרצדורות או לכמס מידע, נשתמש בDLL.

לגבי .NET, ה-NameSpace נמצא בתוךDLL.
אין זה אומר שDLL הוא NameSpace. וגם לא להיפך.
אלא שייבוא NameSpace הוא באמצעות DLL.

אני צודק?

פורסם במקור בפורום CODE613 ב22/02/2016 14:38 (+02:00)

ולמה שלא תעשה בOnClosing של הWPF את הקריאה ל:
UnhookWindowsHookEx(ptrHook);
?
או בOnClosed. (הוא נקרא אחרי ה-OnClosing).

פורסם במקור בפורום CODE613 ב18/02/2016 00:36 (+02:00)

@avr416

@דוד ל.ט.

אז כמובן שייבאתי את הDLL של System.Windows.Forms כיון שאחרת הוא לא מכיר את הEnum שנקרא Keys..

למיטב ידיעתי זה לא נקרא DLL. אלא NameSpace. (מרחב שמות).

פורסם במקור בפורום CODE613 ב18/02/2016 00:34 (+02:00)

אני בעד להישאר ב-WPF.
אפילו שהגישה של WinForm יותר עתיקה.
היום הדברים משתנים כל הזמן.

פורסם במקור בפורום CODE613 ב18/02/2016 00:31 (+02:00)

@avr416

@םןץףך
איזה אטרביוטים?

תביא ציטוט.
בכלל לא ראיתי אטרביוטים.

במחלקה ליצירת דסקטופ, יש שם הרבה כאלה.. אבל אם הבנתי נכון אז זה אומר למהדר להשתמש בDLL שמובנים במערכת, כעין API לוינדוס.

אה...
זה?

[DllImport("kernel32.dll")]

כך כותבים API בC#.
באיזה שפה\ות אתה כותב?

פורסם במקור בפורום CODE613 ב16/02/2016 12:04 (+02:00)

ויש מקלדת וירטואלית?
אם כן צריך לבדוק האם הctrl alt del לא משפיע.
(בוינדוס 7 אני חושב שאין בעיה. תבדוק בוינדוס 8).

פורסם במקור בפורום CODE613 ב16/02/2016 12:01 (+02:00)

איזה אטרביוטים?
תביא ציטוט.
בכלל לא ראיתי אטרביוטים.

פורסם במקור בפורום CODE613 ב15/02/2016 13:18 (+02:00)

שיהיה בהצלחה.

פורסם במקור בפורום CODE613 ב13/02/2016 23:54 (+02:00)

יצירת דסקטופ הוא בתחום C#.
(איך מעלים קבצים?).
לא צריך לבטל CTRL+ALT+DEL.
רק לשנות ברגיסטרי שלא תהיה שם שום אפשרות של כיבוי וכו'.
קובץ REG:

Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer]
"NoDriveTypeAutoRun"=dword:000000FF
"NoLogoff"=dword:00000001
"NoClose"=dword:00000001

[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\System]
"DisableLockWorkstation"=dword:00000001
"DisableTaskMgr"=dword:00000001
"DisableChangePassword"=dword:00000001

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System]
"HideFastUserSwitching"=dword:00000001

[HKEY_CURRENT_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer]
"NoDriveTypeAutoRun"=dword:000000FF

מחלקה ליצירת דסקטופ C#: (לא שלי).

#region License
// Desktop 1.1
//																																							*
// Copyright (C) 2004  http://www.onyeyiri.co.uk
// Coded by: Nnamdi Onyeyiri
//
// This code may be used in any way you desire except for commercial use.
// The code can be freely redistributed unmodified as long as all of the authors 
// copyright notices remain intact, as long as it is not being sold for profit.
// Although I have tried to ensure the stability of the code, I will not take 
// responsibility for any loss, damages, or death it may cause.
//
// This software is provided "as is" without any expressed or implied warranty.
//
// -------------------------
// Change Log
//
// Version 1.0:  -First Release
//
// Version 1.1:  -Added Window and WindowCollection classes
// 6/6/2004      -Added another GetWindows overload, that used WindowCollection
//               -Added GetInputProcesses method to retrieve processes on Input desktop
//               -Changed GetWindows and GetDesktops to return arrays, instead of them being passed by ref
//
// Version 1.2   -Implemented IDisposable
// 8/7/2004      -Implemented ICloneable
//               -Overrided ToString to return desktop name
#endregion

using System;
using System.Threading;
using System.Collections;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Collections.Specialized;

namespace Onyeyiri
{
	/// <summary>
	/// Encapsulates the Desktop API.
	/// </summary>
	public class Desktop : IDisposable, ICloneable
	{
		#region Imports
		[DllImport("kernel32.dll")]
		private static extern int GetThreadId(IntPtr thread);

		[DllImport("kernel32.dll")]
		private static extern int GetProcessId(IntPtr process);

		//
		// Imported winAPI functions.
		//
		[DllImport("user32.dll")]
		private static extern IntPtr CreateDesktop(string lpszDesktop, IntPtr lpszDevice, IntPtr pDevmode, int dwFlags, long dwDesiredAccess, IntPtr lpsa); 

		[DllImport("user32.dll")]
		private static extern bool CloseDesktop(IntPtr hDesktop);

		[DllImport("user32.dll")]
		private static extern IntPtr OpenDesktop(string lpszDesktop, int dwFlags, bool fInherit, long dwDesiredAccess);

		[DllImport("user32.dll")]
		private static extern IntPtr OpenInputDesktop(int dwFlags, bool fInherit, long dwDesiredAccess);

		[DllImport("user32.dll")]
		private static extern bool SwitchDesktop(IntPtr hDesktop);

		[DllImport("user32.dll")]
		private static extern bool EnumDesktops(IntPtr hwinsta, EnumDesktopProc lpEnumFunc, IntPtr lParam);

		[DllImport("user32.dll")]
		private static extern IntPtr GetProcessWindowStation();

		[DllImport("user32.dll")]
		private static extern bool EnumDesktopWindows(IntPtr hDesktop, EnumDesktopWindowsProc lpfn, IntPtr lParam);

		[DllImport("user32.dll")]
		private static extern bool SetThreadDesktop(IntPtr hDesktop);

		[DllImport("user32.dll")]
		private static extern IntPtr GetThreadDesktop(int dwThreadId);

		[DllImport("user32.dll")]
		private static extern bool GetUserObjectInformation(IntPtr hObj, int nIndex, IntPtr pvInfo, int nLength, ref int lpnLengthNeeded);

		[DllImport("kernel32.dll")]
		private static extern bool CreateProcess(
			string lpApplicationName,
			string lpCommandLine,
			IntPtr lpProcessAttributes,
			IntPtr lpThreadAttributes,
			bool bInheritHandles,
			int dwCreationFlags,
			IntPtr lpEnvironment,
			string lpCurrentDirectory,
			ref STARTUPINFO lpStartupInfo,
			ref PROCESS_INFORMATION lpProcessInformation
			);

		[DllImport("user32.dll")]
		private static extern int GetWindowText(IntPtr hWnd, IntPtr lpString, int nMaxCount);

		private delegate bool EnumDesktopProc(string lpszDesktop, IntPtr lParam);
		private delegate bool EnumDesktopWindowsProc(IntPtr desktopHandle, IntPtr lParam);

		[StructLayout(LayoutKind.Sequential)]
		private struct PROCESS_INFORMATION 
		{
			public IntPtr hProcess;
			public IntPtr hThread;
			public int dwProcessId;
			public int dwThreadId;
		}

		[StructLayout(LayoutKind.Sequential)]
		private struct STARTUPINFO 
		{
			public int cb;
			public string lpReserved;
			public string lpDesktop;
			public string lpTitle;
			public int dwX;
			public int dwY;
			public int dwXSize;
			public int dwYSize;
			public int dwXCountChars;
			public int dwYCountChars;
			public int dwFillAttribute;
			public int dwFlags;
			public short wShowWindow;
			public short cbReserved2;
			public IntPtr lpReserved2;
			public IntPtr hStdInput;
			public IntPtr hStdOutput;
			public IntPtr hStdError;
		}
		#endregion

		#region Constants
		/// <summary>
		/// Size of buffer used when retrieving window names.
		/// </summary>
		public const int MaxWindowNameLength = 100;

		//
		// winAPI constants.
		//
		private const short SW_HIDE = 0;
		private const short SW_NORMAL = 1;
		private const int STARTF_USESTDHANDLES = 0x00000100;
		private const int STARTF_USESHOWWINDOW = 0x00000001;
		private const int UOI_NAME = 2;
		private const int STARTF_USEPOSITION = 0x00000004;
		private const int NORMAL_PRIORITY_CLASS = 0x00000020;
		private const long DESKTOP_CREATEWINDOW = 0x0002L;
		private const long DESKTOP_ENUMERATE = 0x0040L;
		private const long DESKTOP_WRITEOBJECTS = 0x0080L;
		private const long DESKTOP_SWITCHDESKTOP = 0x0100L;
		private const long DESKTOP_CREATEMENU = 0x0004L;
		private const long DESKTOP_HOOKCONTROL = 0x0008L;
		private const long DESKTOP_READOBJECTS = 0x0001L;
		private const long DESKTOP_JOURNALRECORD = 0x0010L;
		private const long DESKTOP_JOURNALPLAYBACK = 0x0020L;
		private const long AccessRights = DESKTOP_JOURNALRECORD | DESKTOP_JOURNALPLAYBACK | DESKTOP_CREATEWINDOW | DESKTOP_ENUMERATE | DESKTOP_WRITEOBJECTS | DESKTOP_SWITCHDESKTOP | DESKTOP_CREATEMENU | DESKTOP_HOOKCONTROL | DESKTOP_READOBJECTS;
		#endregion

		#region Structures
		/// <summary>
		/// Stores window handles and titles.
		/// </summary>
		public struct Window
		{
			#region Private Variables
			private IntPtr m_handle;
			private string m_text;
			#endregion

			#region Public Properties
			/// <summary>
			/// Gets the window handle.
			/// </summary>
			public IntPtr Handle
			{
				get
				{
					return m_handle;
				}
			}

			/// <summary>
			/// Gets teh window title.
			/// </summary>
			public string Text
			{
				get
				{
					return m_text;
				}
			}
			#endregion

			#region Construction
			/// <summary>
			/// Creates a new window object.
			/// </summary>
			/// <param name="handle">Window handle.</param>
			/// <param name="text">Window title.</param>
			public Window(IntPtr handle, string text)
			{
				m_handle = handle;
				m_text = text;
			}
			#endregion
		}

		/// <summary>
		/// A collection for Window objects.
		/// </summary>
		public class WindowCollection : CollectionBase
		{
			#region Public Properties
			/// <summary>
			/// Gets a window from teh collection.
			/// </summary>
			public Window this[int index]
			{
				get
				{
					return (Window)List[index];
				}
			}
			#endregion

			#region Methods
			/// <summary>
			/// Adds a window to the collection.
			/// </summary>
			/// <param name="wnd">Window to add.</param>
			public void Add(Window wnd)
			{
				// adds a widow to the collection.
				List.Add(wnd);
			}
			#endregion
		}
		#endregion

		#region Private Variables
		private IntPtr m_desktop;
		private string m_desktopName;
		private static StringCollection m_sc;
		private ArrayList m_windows;
		private bool m_disposed;
		#endregion

		#region Public Properties
		/// <summary>
		/// Gets if a desktop is open.
		/// </summary>
		public bool IsOpen
		{
			get
			{
				return (m_desktop != IntPtr.Zero);
			}
		}

		/// <summary>
		/// Gets the name of the desktop, returns null if no desktop is open.
		/// </summary>
		public string DesktopName
		{
			get
			{
				return m_desktopName;
			}
		}

		/// <summary>
		/// Gets a handle to the desktop, IntPtr.Zero if no desktop open.
		/// </summary>
		public IntPtr DesktopHandle
		{
			get
			{
				return m_desktop;
			}
		}

		/// <summary>
		/// Opens the default desktop.
		/// </summary>
		public static readonly Desktop Default = Desktop.OpenDefaultDesktop();

		/// <summary>
		/// Opens the desktop the user if viewing.
		/// </summary>
		public static readonly Desktop Input = Desktop.OpenInputDesktop();
		#endregion

		#region Construction/Destruction
		/// <summary>
		/// Creates a new Desktop object.
		/// </summary>
		public Desktop()
		{
			// init variables.
			m_desktop = IntPtr.Zero;
			m_desktopName = String.Empty;
			m_windows = new ArrayList();
			m_disposed = false;
		}

		// constructor is private to prevent invalid handles being passed to it.
		private Desktop(IntPtr desktop)
		{
			// init variables.
			m_desktop = desktop;
			m_desktopName = Desktop.GetDesktopName(desktop);
			m_windows = new ArrayList();
			m_disposed = false;
		}

		~Desktop()
		{
			// clean up, close the desktop.
			Close();
		}
		#endregion

		#region Methods
		/// <summary>
		/// Creates a new desktop.  If a handle is open, it will be closed.
		/// </summary>
		/// <param name="name">The name of the new desktop.  Must be unique, and is case sensitive.</param>
		/// <returns>True if desktop was successfully created, otherwise false.</returns>
		public bool Create(string name)
		{
			// make sure object isnt disposed.
			CheckDisposed();

			// close the open desktop.
			if (m_desktop != IntPtr.Zero)
			{
				// attempt to close the desktop.
				if (!Close()) return false;
			}
	
			// make sure desktop doesnt already exist.
			if (Desktop.Exists(name))
			{
				// it exists, so open it.
				return Open(name);
			}

			// attempt to create desktop.
			m_desktop = CreateDesktop(name, IntPtr.Zero, IntPtr.Zero, 0, AccessRights, IntPtr.Zero);

			m_desktopName = name;

			// something went wrong.
			if (m_desktop == IntPtr.Zero) return false;

			return true;
		}
		
		/// <summary>
		/// Closes the handle to a desktop.
		/// </summary>
		/// <returns>True if an open handle was successfully closed.</returns>
		public bool Close()
		{
			// make sure object isnt disposed.
			CheckDisposed();

			// check there is a desktop open.
			if (m_desktop != IntPtr.Zero)
			{
				// close the desktop.
				bool result = CloseDesktop(m_desktop);

				if (result)
				{
					m_desktop = IntPtr.Zero;

					m_desktopName = String.Empty;
				}

				return result;
			}

			// no desktop was open, so desktop is closed.
			return true;
		}

		/// <summary>
		/// Opens a desktop.
		/// </summary>
		/// <param name="name">The name of the desktop to open.</param>
		/// <returns>True if the desktop was successfully opened.</returns>
		public bool Open(string name)
		{
			// make sure object isnt disposed.
			CheckDisposed();

			// close the open desktop.
			if (m_desktop != IntPtr.Zero)
			{
				// attempt to close the desktop.
				if (!Close()) return false;
			}

			// open the desktop.
			m_desktop = OpenDesktop(name, 0, true, AccessRights);

			// something went wrong.
			if (m_desktop == IntPtr.Zero) return false;

			m_desktopName = name;

			return true;
		}

		/// <summary>
		/// Opens the current input desktop.
		/// </summary>
		/// <returns>True if the desktop was succesfully opened.</returns>
		public bool OpenInput()
		{
			// make sure object isnt disposed.
			CheckDisposed();

			// close the open desktop.
			if (m_desktop != IntPtr.Zero)
			{
				// attempt to close the desktop.
				if (!Close()) return false;
			}

			// open the desktop.
			m_desktop = OpenInputDesktop(0, true, AccessRights);

			// something went wrong.
			if (m_desktop == IntPtr.Zero) return false;

			// get the desktop name.
			m_desktopName = Desktop.GetDesktopName(m_desktop);

			return true;
		}

		/// <summary>
		/// Switches input to the currently opened desktop.
		/// </summary>
		/// <returns>True if desktops were successfully switched.</returns>
		public bool Show()
		{
			// make sure object isnt disposed.
			CheckDisposed();

			// make sure there is a desktop to open.
			if (m_desktop == IntPtr.Zero) return false;

			// attempt to switch desktops.
			bool result = SwitchDesktop(m_desktop);

			return result;
		}

		/// <summary>
		/// Enumerates the windows on a desktop.
		/// </summary>
		/// <param name="windows">Array of Desktop.Window objects to recieve windows.</param>
		/// <returns>A window colleciton if successful, otherwise null.</returns>
		public WindowCollection GetWindows()
		{
			// make sure object isnt disposed.
			CheckDisposed();

			// make sure a desktop is open.
			if (!IsOpen) return null;

			// init the arraylist.
			m_windows.Clear();
			WindowCollection windows = new WindowCollection();

			// get windows.
			bool result = EnumDesktopWindows(m_desktop, new EnumDesktopWindowsProc(DesktopWindowsProc), IntPtr.Zero);

			// check for error.
			if (!result) return null;

			// get window names.
			windows = new WindowCollection();

			IntPtr ptr = Marshal.AllocHGlobal(MaxWindowNameLength);

			foreach(IntPtr wnd in m_windows)
			{
				GetWindowText(wnd, ptr, MaxWindowNameLength);
				windows.Add(new Window(wnd, Marshal.PtrToStringAnsi(ptr)));
			}

			Marshal.FreeHGlobal(ptr);

			return windows;
		}

		private bool DesktopWindowsProc(IntPtr wndHandle, IntPtr lParam)
		{
			// add window handle to colleciton.
			m_windows.Add(wndHandle);

			return true;
		}

		/// <summary>
		/// Creates a new process in a desktop.
		/// </summary>
		/// <param name="path">Path to application.</param>
		/// <returns>The process object for the newly created process.</returns>
		public Process CreateProcess(string path)
		{
			// make sure object isnt disposed.
			CheckDisposed();

			// make sure a desktop is open.
			if (!IsOpen) return null;

			// set startup parameters.
			STARTUPINFO si = new STARTUPINFO();
			si.cb = Marshal.SizeOf(si);
			si.lpDesktop = m_desktopName;

			PROCESS_INFORMATION pi = new PROCESS_INFORMATION();

			// start the process.
			bool result = CreateProcess(null,path , IntPtr.Zero, IntPtr.Zero, true, NORMAL_PRIORITY_CLASS, IntPtr.Zero, null, ref si, ref pi);

			// error?
			if (!result) return null;
            
			// Get the process.
			return Process.GetProcessById(pi.dwProcessId);
		}
        /// <summary>
        /// Creates a new process in a desktop.
        /// </summary>
        /// <param name="path">Path to application.</param>
        /// <returns>The process object for the newly created process.</returns>
        public Process CreateProcess2(string path, string commandLine, string currentDirectory)
        {
            // make sure object isnt disposed.
            CheckDisposed();

            // make sure a desktop is open.
            if (!IsOpen) return null;

            // set startup parameters.
            STARTUPINFO si = new STARTUPINFO();
            si.cb = Marshal.SizeOf(si);
            si.lpDesktop = m_desktopName;

            PROCESS_INFORMATION pi = new PROCESS_INFORMATION();

            // start the process.
            bool result = CreateProcess(path, commandLine, IntPtr.Zero, IntPtr.Zero, true, NORMAL_PRIORITY_CLASS, IntPtr.Zero, currentDirectory, ref si, ref pi);

            // error?
            if (!result) return null;

            // Get the process.
            return Process.GetProcessById(pi.dwProcessId);
        }
		/// <summary>
		/// Prepares a desktop for use.  For use only on newly created desktops, call straight after CreateDesktop.
		/// </summary>
		public void Prepare()
		{
			// make sure object isnt disposed.
			CheckDisposed();

			// make sure a desktop is open.
			if (IsOpen)
			{
				// load explorer.
				CreateProcess("explorer.exe");
			}
		}
		#endregion

		#region Static Methods
		/// <summary>
		/// Enumerates all of the desktops.
		/// </summary>
		/// <param name="desktops">String array to recieve desktop names.</param>
		/// <returns>True if desktop names were successfully enumerated.</returns>
		public static string[] GetDesktops()
		{
			// attempt to enum desktops.
			IntPtr windowStation = GetProcessWindowStation();

			// check we got a valid handle.
			if (windowStation == IntPtr.Zero) return new string[0];

			string[] desktops;

			// lock the object. thread safety and all.
			lock(m_sc = new StringCollection())
			{
				bool result = EnumDesktops(windowStation, new EnumDesktopProc(DesktopProc), IntPtr.Zero);

				// something went wrong.
				if (!result) return new string[0];

				//	// turn the collection into an array.
				desktops = new string[m_sc.Count];
				for(int i = 0; i < desktops.Length; i++) desktops[i] = m_sc[i];
			}

			return desktops;
		}

		private static bool DesktopProc(string lpszDesktop, IntPtr lParam)
		{
			// add the desktop to the collection.
			m_sc.Add(lpszDesktop);

			return true;
		}

		/// <summary>
		/// Switches to the specified desktop.
		/// </summary>
		/// <param name="name">Name of desktop to switch input to.</param>
		/// <returns>True if desktops were successfully switched.</returns>
		public static bool Show(string name)
		{
			// attmempt to open desktop.
			bool result = false;

			using (Desktop d = new Desktop())
			{
				result = d.Open(name);

				// something went wrong.
				if (!result) return false;

				// attempt to switch desktops.
				result = d.Show();
			}

			return result;
		}

		/// <summary>
		/// Gets the desktop of the calling thread.
		/// </summary>
		/// <returns>Returns a Desktop object for the valling thread.</returns>
		public static Desktop GetCurrent()
		{
			// get the desktop.
			return new Desktop(GetThreadDesktop(AppDomain.GetCurrentThreadId()));
		}

		/// <summary>
		/// Sets the desktop of the calling thread.
		/// NOTE: Function will fail if thread has hooks or windows in the current desktop.
		/// </summary>
		/// <param name="desktop">Desktop to put the thread in.</param>
		/// <returns>True if the threads desktop was successfully changed.</returns>
		public static bool SetCurrent(Desktop desktop)
		{
			// set threads desktop.
			if (!desktop.IsOpen) return false;

			return SetThreadDesktop(desktop.DesktopHandle);
		}

		/// <summary>
		/// Opens a desktop.
		/// </summary>
		/// <param name="name">The name of the desktop to open.</param>
		/// <returns>If successful, a Desktop object, otherwise, null.</returns>
		public static Desktop OpenDesktop(string name)
		{
			// open the desktop.
			Desktop desktop = new Desktop();
			bool result = desktop.Open(name);

			// somethng went wrong.
			if (!result) return null;

			return desktop;
		}

		/// <summary>
		/// Opens the current input desktop.
		/// </summary>
		/// <returns>If successful, a Desktop object, otherwise, null.</returns>
		public static Desktop OpenInputDesktop()
		{
			// open the desktop.
			Desktop desktop = new Desktop();
			bool result = desktop.OpenInput();

			// somethng went wrong.
			if (!result) return null;

			return desktop;
		}

		/// <summary>
		/// Opens the default desktop.
		/// </summary>
		/// <returns>If successful, a Desktop object, otherwise, null.</returns>
		public static Desktop OpenDefaultDesktop()
		{
			// opens the default desktop.
			return Desktop.OpenDesktop("Default");
		}

		/// <summary>
		/// Creates a new desktop.
		/// </summary>
		/// <param name="name">The name of the desktop to create.  Names are case sensitive.</param>
		/// <returns>If successful, a Desktop object, otherwise, null.</returns>
		public static Desktop CreateDesktop(string name)
		{
			// open the desktop.
			Desktop desktop = new Desktop();
			bool result = desktop.Create(name);

			// somethng went wrong.
			if (!result) return null;

			return desktop;
		}

		/// <summary>
		/// Gets the name of a given desktop.
		/// </summary>
		/// <param name="desktop">Desktop object whos name is to be found.</param>
		/// <returns>If successful, the desktop name, otherwise, null.</returns>
		public static string GetDesktopName(Desktop desktop)
		{
			// get name.
			if (desktop.IsOpen) return null;

			return GetDesktopName(desktop.DesktopHandle);
		}

		/// <summary>
		/// Gets the name of a desktop from a desktop handle.
		/// </summary>
		/// <param name="desktopHandle"></param>
		/// <returns>If successful, the desktop name, otherwise, null.</returns>
		public static string GetDesktopName(IntPtr desktopHandle)
		{
			// check its not a null pointer.
			// null pointers wont work.
			if (desktopHandle == IntPtr.Zero) return null;

			// get the length of the name.
			int needed = 0;
			string name = String.Empty;
			GetUserObjectInformation(desktopHandle, UOI_NAME, IntPtr.Zero, 0, ref needed);

			// get the name.
			IntPtr ptr = Marshal.AllocHGlobal(needed);
			bool result = GetUserObjectInformation(desktopHandle, UOI_NAME, ptr, needed, ref needed);
			name = Marshal.PtrToStringAnsi(ptr);
			Marshal.FreeHGlobal(ptr);

			// something went wrong.
			if (!result) return null;

			return name;
		}

		/// <summary>
		/// Checks if the specified desktop exists (using a case sensitive search).
		/// </summary>
		/// <param name="name">The name of the desktop.</param>
		/// <returns>True if the desktop exists, otherwise false.</returns>
		public static bool Exists(string name)
		{
			return Desktop.Exists(name, false);
		}

		/// <summary>
		/// Checks if the specified desktop exists.
		/// </summary>
		/// <param name="name">The name of the desktop.</param>
		/// <param name="caseInsensitive">If the search is case INsensitive.</param>
		/// <returns>True if the desktop exists, otherwise false.</returns>
		public static bool Exists(string name, bool caseInsensitive)
		{
			// enumerate desktops.
			string[] desktops = Desktop.GetDesktops();

			// return true if desktop exists.
			foreach(string desktop in desktops)
			{
				if (caseInsensitive)
				{
					// case insensitive, compare all in lower case.
					if (desktop.ToLower() == name.ToLower()) return true;
				}
				else
				{
					if (desktop == name) return true;
				}
			}

			return false;
		}

		/// <summary>
		/// Creates a new process on the specified desktop.
		/// </summary>
		/// <param name="path">Path to application.</param>
		/// <param name="desktop">Desktop name.</param>
		/// <returns>A Process object for the newly created process, otherwise, null.</returns>
		public static Process CreateProcess(string path, string desktop)
		{
			if (!Desktop.Exists(desktop)) return null;

			// create the process.
			Desktop d = Desktop.OpenDesktop(desktop);
			return d.CreateProcess(path);
		}

		/// <summary>
		/// Gets an array of all the processes running on the Input desktop.
		/// </summary>
		/// <returns>An array of the processes.</returns>
		public static Process[] GetInputProcesses()
		{
			// get all processes.
			Process[] processes = Process.GetProcesses();

			ArrayList m_procs = new ArrayList();

			// get the current desktop name.
			string currentDesktop = GetDesktopName(Desktop.Input.DesktopHandle);

			// cycle through the processes.
			foreach(Process process in processes)
			{
				// check the threads of the process - are they in this one?
				foreach(ProcessThread pt in process.Threads)
				{
					// check for a desktop name match.
					if (GetDesktopName(GetThreadDesktop(pt.Id)) == currentDesktop)
					{
						// found a match, add to list, and bail.
						m_procs.Add(process);
						break;
					}
				}
			}

			// put ArrayList into array.
			Process[] procs = new Process[m_procs.Count];

			for(int i = 0; i < procs.Length; i++) procs[i] = (Process)m_procs[i];

			return procs;
		}
		#endregion

		#region IDisposable
		/// <summary>
		/// Dispose Object.
		/// </summary>
		public void Dispose()
		{
			// dispose
			Dispose(true);

			// suppress finalisation
			GC.SuppressFinalize(this);
		}

		/// <summary>
		/// Dispose Object.
		/// </summary>
		/// <param name="disposing">True to dispose managed resources.</param>
		public virtual void Dispose(bool disposing)
		{
			if (!m_disposed)
			{
				// dispose of managed resources,
				// close handles
				Close();
			}

			m_disposed = true;
		}

		private void CheckDisposed()
		{
			// check if disposed
			if (m_disposed)
			{
				// object disposed, throw exception
				throw new ObjectDisposedException("");
			}
		}
		#endregion

		#region ICloneable
		/// <summary>
		/// Creates a new Desktop object with the same desktop open.
		/// </summary>
		/// <returns>Cloned desktop object.</returns>
		public object Clone()
		{
			// make sure object isnt disposed.
			CheckDisposed();

			Desktop desktop = new Desktop();

			// if a desktop is open, make the clone open it.
			if (IsOpen) desktop.Open(m_desktopName);

			return desktop;
		}
		#endregion

		#region Overrides
		/// <summary>
		/// Gets the desktop name.
		/// </summary>
		/// <returns>The desktop name, or a blank string if no desktop open.</returns>
		public override string ToString()
		{
			// return the desktop name.
			return m_desktopName;
		}
		#endregion
	}
}

פורסם במקור בפורום CODE613 ב13/02/2016 23:30 (+02:00)

עשיתי תוכנה כזאת, כמו קול הלשון.
מאוד פשוט. (לאחר מעשה...).
ב-C#.
צריך לעשות הוק. ושהתוכנה תפעל בהפעלת המחשב.
כמו כן ישנה בעיה של תוכנות אחרות שקופצות (כגון התרעות שונות על עדכונים וכדו'. או אם אתה משתלט בTeamViewer).
לכן תשקול אפשרות להשתמש ביצירת Desktop חדש.
חפש בגוגל: CreateDesktop.
אשמח לעזור.

פורסם במקור בפורום CODE613 ב11/02/2016 00:11 (+02:00)