8
votes

Algorithme pour des heures occupées en jour par des tâches

[global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Schedule")]
public partial class Schedule : INotifyPropertyChanging, INotifyPropertyChanged
{
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    private int _ScheduleID;
    private System.Nullable<System.DateTime> _DateFrom;
    private System.Nullable<decimal> _Hours;
    private System.Nullable<int> _EmployeID;
    private System.Nullable<int> _RecurringID;
    private System.Nullable<int> _Priority;
    private System.Nullable<System.DateTime> _DateTo;
    private bool _IsLocked;
    private System.Nullable<int> _BumpPriority;
    private EntitySet<Case> _Cases;
    private EntitySet<Project> _Projects;
    private EntitySet<Task> _Tasks;
    private EntitySet<Task> _Tasks1;
    private EntityRef<Employee> _Employee;
    private EntityRef<Recurring> _Recurring;

    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(System.Data.Linq.ChangeAction action);
    partial void OnCreated();
    partial void OnScheduleIDChanging(int value);
    partial void OnScheduleIDChanged();
    partial void OnDateFromChanging(System.Nullable<System.DateTime> value);
    partial void OnDateFromChanged();
    partial void OnHoursChanging(System.Nullable<decimal> value);
    partial void OnHoursChanged();
    partial void OnEmployeIDChanging(System.Nullable<int> value);
    partial void OnEmployeIDChanged();
    partial void OnRecurringIDChanging(System.Nullable<int> value);
    partial void OnRecurringIDChanged();
    partial void OnPriorityChanging(System.Nullable<int> value);
    partial void OnPriorityChanged();
    partial void OnDateToChanging(System.Nullable<System.DateTime> value);
    partial void OnDateToChanged();
    partial void OnIsLockedChanging(bool value);
    partial void OnIsLockedChanged();
    partial void OnBumpPriorityChanging(System.Nullable<int> value);
    partial void OnBumpPriorityChanged();
    #endregion

    public Schedule()
    {
        this._Cases = new EntitySet<Case>(new Action<Case>(this.attach_Cases), new Action<Case>(this.detach_Cases));
        this._Projects = new EntitySet<Project>(new Action<Project>(this.attach_Projects), new Action<Project>(this.detach_Projects));
        this._Tasks = new EntitySet<Task>(new Action<Task>(this.attach_Tasks), new Action<Task>(this.detach_Tasks));
        this._Tasks1 = new EntitySet<Task>(new Action<Task>(this.attach_Tasks1), new Action<Task>(this.detach_Tasks1));
        this._Employee = default(EntityRef<Employee>);
        this._Recurring = default(EntityRef<Recurring>);
        OnCreated();
    }
}

7 commentaires

Pourriez-vous, UH, essayer de condenser votre problème dans un ensemble de phrases clairement défini ou au moins clairement marqué? Il m'a fallu un peu de temps pour trouver la question actuelle.


Je ne sais pas comment le modifier de cette façon ... Essentiellement, commencez à la journée cible, puis retournez à l'envers jusqu'à ce que rien ne soit reporté d'un autre jour, à partir de là, commencez à compter des heures et à garder une trace de la portée des heures. Considérez également que la durée de la journée peut être raccourcie en raison de la durée verrouillée ... Ensuite, une fois que vous savez que vous êtes revenez à la cible, puis calculez les heures occupées réelles.


J'ai essayé de mettre cela dans une sorte d'étapes.


Pourquoi commencer à la journée cible et aller en arrière? La journée cible est-elle le point d'achèvement souhaité?


J'ai besoin de résoudre pendant nombre des heures que l'employé a programmé pour la cible, c'est pourquoi.


Pourquoi ne pas dire que la journée cible est le premier jour, le projet peut être travaillé et des processus de là-bas? Continuez jusqu'à ce que vous ayez des heures gratuites, puis commencez à appliquer ces heures.


Trop de texte sur une question trop générique. Même si vous donnez les données complètes que vous avez faites (TLDR;) c'est beaucoup de travail. Pouvez-vous plutôt donner moins de données et demander quelque chose de spécifique?


3 Réponses :


0
votes

comme tel:

  1. Créez une liste des jours avec du temps libre.
  2. Pour chaque élément de la liste, ajoutez le maximum de temps disponible pour votre tâche.
  3. Si le temps nécessaire à votre projet atteint 0, arrêtez d'ajouter des blocs.

0 commentaires

1
votes

Même si vous avez une question est très complexe et pas très clairement expliqué, je vais essayer de y répondre. Ou plus précisément vous indiquer comment vous devez décomposer et résoudre (ou comment je le résoudrais).

Ce dont j'ai besoin, c'est un algorithme qui peut me dire correctement combien d'heures sont en réalité occupées en une journée.

Au début, je ne vois pas le problème réel au cas où vous auriez DateTo disponible pour calendrier . Sauf si cela est égal à Datefrom + heures . Dans ce cas, il ne reflète pas la valeur réelle DateTo mais une valeur quelque peu pertinente à la place.

Je présumerai tout calendrier est défini par le temps de démarrage Datefrom et durée heures . DateTo est la valeur calculée et l'informatique efficace est le noyau réel du problème.

Donc, je pense que cette fonction se met à disposition des heures à tout moment est assez simple. Parlant en pseudo-code: xxx

Vous avez peut-être besoin de quelques ajustements car le DateTime attend normal de 24 heures de 24 heures.


0 commentaires

0
votes

Cela ne répond pas à la question exacte, mais je suggérerais de simplifier votre logique en étendant vos classes (objets) avec des méthodes d'assistance, par ex. Méthodes / propriétés qui renvoient des listes de jours occupées. Si vous ne pouvez pas accéder à ces classes (c'est-à-dire, ils ne sont pas à partir de votre base de code) - créez ensuite de nouvelles classes et de la carte à celles-ci. Aussi - la classe DateTime .NET a des propriétés très utiles et des énumes telles que "Dayofweek" et "TimeOfday" qui pourrait être utile pour vous.


0 commentaires